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

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

@@ -34,6 +34,7 @@ import {
     Command,
     FabricIndex,
     StatusCode,
+    StatusResponse,
     StatusResponseError,
     TlvBoolean,
     TlvByteString,
@@ -41,8 +42,10 @@ import {
     TlvObject,
     TlvOptionalField,
     ValidationError,
+    VendorId,
 } from "#types";
 import { OperationalCredentialsBehavior } from "./OperationalCredentialsBehavior.js";
+import { VendorIdVerification } from "./VendorIdVerification.js";
 
 const logger = Logger.get("OperationalCredentials");
 
@@ -85,7 +88,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
     declare state: OperationalCredentialsServer.State;
 
     override initialize(): MaybePromise {
-        // maximum number of fabrics. Also FabricBuilder uses 254 as max!
+        // maximum number of fabrics. Also, FabricBuilder uses 254 as max!
         if (!this.state.supportedFabrics) {
             this.state.supportedFabrics = 254;
         }
@@ -454,6 +457,54 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
         this.state.trustedRootCertificates = trustedRootCertificates;
     }
 
+    override async signVidVerificationRequest({
+        fabricIndex,
+        clientChallenge,
+    }: OperationalCredentials.SignVidVerificationRequest): Promise<OperationalCredentials.SignVidVerificationResponse> {
+        assertRemoteActor(this.context);
+        NodeSession.assert(this.context.session);
+
+        const fabrics = this.env.get(FabricManager);
+        if (!fabrics.has(fabricIndex)) {
+            throw new StatusResponse.ConstraintErrorError(`Fabric with index ${fabricIndex} does not exist`);
+        }
+        const fabric = fabrics.for(fabricIndex);
+
+        const { fabricBindingVersion, signatureData } = VendorIdVerification.dataToSign({
+            attChallenge: this.context.session.attestationChallengeKey,
+            clientChallenge,
+            fabricIndex,
+            fabric: fabric.config,
+        });
+
+        return {
+            fabricIndex,
+            fabricBindingVersion,
+            signature: await fabric.sign(signatureData),
+        };
+    }
+
+    override async setVidVerificationStatement({
+        vendorId,
+        vidVerificationStatement,
+        vvsc,
+    }: OperationalCredentials.SetVidVerificationStatementRequest): Promise<void> {
+        assertRemoteActor(this.context);
+        const fabric = this.context.session.associatedFabric;
+
+        if (vendorId === undefined && vidVerificationStatement === undefined && vvsc === undefined) {
+            throw new StatusResponse.InvalidCommandError(
+                "At least one of vendorId, vidVerificationStatement or vvsc must be provided",
+            );
+        }
+        if (vendorId !== undefined && !VendorId.isValid(vendorId)) {
+            throw new StatusResponse.ConstraintErrorError(`Invalid vendorId: ${vendorId}`);
+        }
+
+        // Error checks included in updateVendorVerificationData method
+        await fabric.updateVendorVerificationData(vendorId, vidVerificationStatement, vvsc);
+    }
+
     async #updateFabrics() {
         const fabrics = this.env.get(FabricManager);
         this.state.fabrics = fabrics.map(fabric => ({
@@ -462,12 +513,14 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             nodeId: fabric.nodeId,
             rootPublicKey: fabric.rootPublicKey,
             vendorId: fabric.rootVendorId,
+            vidVerificationStatement: fabric.vidVerificationStatement,
             fabricIndex: fabric.fabricIndex,
         }));
 
         this.state.nocs = fabrics.map(fabric => ({
             noc: fabric.operationalCert,
             icac: fabric.intermediateCACert ?? null,
+            vvsc: fabric.vvsc,
             fabricIndex: fabric.fabricIndex,
         }));
 

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

@@ -0,0 +1,305 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OperationalCredentialsClient } from "#behaviors/operational-credentials";
+import { OperationalCredentials } from "#clusters/operational-credentials";
+import {
+    Bytes,
+    Crypto,
+    CryptoError,
+    DataReader,
+    DataWriter,
+    Endian,
+    InternalError,
+    Logger,
+    MATTER_CRYPTO_PRIMITIVES_VERSION,
+    PublicKey,
+    UnexpectedDataError,
+} from "#general";
+import { ClientNodeInteraction } from "#node/client/ClientNodeInteraction.js";
+import type { ClientNode } from "#node/ClientNode.js";
+import { Icac, Noc, NodeSession, Rcac, Vvsc } from "#protocol";
+import { FabricId, FabricIndex, ReceivedStatusResponseError, StatusResponse, VendorId } from "#types";
+
+const logger = Logger.get("VendorIdVerification");
+
+const VERIFICATION_STATEMENT_VERSION = 0x21;
+
+// fabric_binding_version (1 byte) || root_public_key || fabric_id (64bit) || vendor_id (16bit)
+// sizeof(uint8_t) + CHIP_CRYPTO_PUBLIC_KEY_SIZE_BYTES + sizeof(uint64_t) + sizeof(uint16_t)
+const FABRIC_BINDING_MESSAGE_SIZE = 76;
+
+// sizeof(uint8_t) + kSubjectKeyIdentifierLength + kP256_ECDSA_Signature_Length_Raw;
+// sizeof(uint8_t) + kSubjectKeyIdentifierLength + kP256_ECDSA_Signature_Length_Raw
+export const VERIFICATION_STATEMENT_SIZE = 85;
+
+const FABRIC_BINDING_VERSION = MATTER_CRYPTO_PRIMITIVES_VERSION;
+
+export namespace VendorIdVerification {
+    export interface SignData {
+        fabricBindingVersion?: number;
+        clientChallenge: Bytes;
+        attChallenge: Bytes;
+        fabricIndex: FabricIndex;
+        fabric: {
+            // A partial variant for Fabric.Config with only the needed details that als a client has
+            rootPublicKey: Bytes;
+            fabricId: FabricId;
+            rootVendorId: VendorId;
+            vidVerificationStatement?: Bytes;
+        };
+    }
+
+    /** Prepare the data to be signed for VID Verification */
+    export function dataToSign(data: SignData) {
+        const {
+            fabricBindingVersion = FABRIC_BINDING_VERSION,
+            clientChallenge,
+            attChallenge,
+            fabricIndex,
+            fabric,
+        } = data;
+
+        if (fabricBindingVersion !== FABRIC_BINDING_VERSION) {
+            throw new InternalError(`Unsupported Fabric Binding Version ${fabricBindingVersion}`);
+        }
+
+        const tbsWriter = new DataWriter(Endian.Big);
+        tbsWriter.writeUInt8(fabricBindingVersion);
+        tbsWriter.writeByteArray(clientChallenge);
+        tbsWriter.writeByteArray(attChallenge);
+        tbsWriter.writeUInt8(fabricIndex);
+
+        // Fabric Binding Message
+        tbsWriter.writeUInt8(fabricBindingVersion);
+        tbsWriter.writeByteArray(fabric.rootPublicKey);
+        tbsWriter.writeUInt64(fabric.fabricId);
+        tbsWriter.writeUInt16(fabric.rootVendorId);
+
+        if (fabric.vidVerificationStatement) {
+            tbsWriter.writeByteArray(fabric.vidVerificationStatement);
+        }
+
+        return {
+            fabricBindingVersion,
+            signatureData: tbsWriter.toByteArray(),
+        };
+    }
+
+    /**
+     * Verify VendorId ownership using VID Verification protocol including needed requests to the device
+     * TODO: Finalize this with DCL data and wire into controller as option
+     *
+     * 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.
+     */
+    export async function verify(
+        node: ClientNode,
+        options: {
+            noc: OperationalCredentials.Noc; // Noc entry read from device for the relevant fabric index
+            rcac: Bytes; // Trusted Root Certificate , TODO: Allow to provide multiple and find the needed one
+            fabric: OperationalCredentials.FabricDescriptor; // Fabric entry read from device for the relevant fabric index
+        },
+    ) {
+        const crypto = node.env.get(Crypto);
+        const clientChallenge = crypto.randomBytes(32);
+        const {
+            fabric: { fabricIndex },
+        } = options;
+        let signVerificationResponse;
+        try {
+            signVerificationResponse = await node
+                .commandsOf(OperationalCredentialsClient)
+                .signVidVerificationRequest({ fabricIndex, clientChallenge });
+            if (fabricIndex !== signVerificationResponse.fabricIndex) {
+                throw new StatusResponse.InvalidCommandError(
+                    `Fabric Index mismatch: expected ${fabricIndex}, got ${signVerificationResponse.fabricIndex}`,
+                );
+            }
+        } catch (error) {
+            ReceivedStatusResponseError.accept(error);
+            logger.error("Could not verify VendorId", error);
+            return undefined;
+        }
+
+        const session = (node.interaction as ClientNodeInteraction).session;
+        if (session === undefined || !NodeSession.is(session)) {
+            // Should not happen when above command was successful
+            logger.error("Could not verify VendorId: no session established");
+            return undefined;
+        }
+
+        const { noc, rcac, fabric } = options;
+        return await verifyData(crypto, {
+            clientChallenge,
+            attChallenge: session.attestationChallengeKey,
+            signVerificationResponse,
+            noc,
+            rcac,
+            fabric,
+        });
+    }
+
+    /**
+     * Verify VendorId ownership using VID Verification protocol on pure data level
+     *
+     * @see {@link MatterSpecification.v142.Cluster} § 6.4.10.1.
+     */
+    export async function verifyData(
+        crypto: Crypto,
+        options: {
+            clientChallenge: Bytes;
+            attChallenge: Bytes;
+            signVerificationResponse: OperationalCredentials.SignVidVerificationResponse;
+            noc: OperationalCredentials.Noc;
+            rcac: Bytes;
+            fabric: OperationalCredentials.FabricDescriptor;
+        },
+    ) {
+        const {
+            clientChallenge,
+            attChallenge,
+            signVerificationResponse: { fabricBindingVersion, signature },
+            noc: { noc, icac, vvsc },
+            rcac,
+            fabric: { vendorId: rootVendorId, vidVerificationStatement, fabricIndex },
+        } = options;
+        const {
+            subject: { fabricId },
+            ellipticCurvePublicKey: rootPublicKey,
+        } = Noc.fromTlv(noc).cert;
+
+        const tbs = dataToSign({
+            fabricBindingVersion,
+            clientChallenge,
+            attChallenge,
+            fabricIndex,
+            fabric: {
+                rootPublicKey,
+                fabricId,
+                rootVendorId,
+                vidVerificationStatement,
+            },
+        }).signatureData;
+
+        try {
+            // Validate signature over TBS data
+            await crypto.verifyEcdsa(PublicKey(rootPublicKey), tbs, signature);
+
+            // Verify Noc cert chain using trusted root
+            const rootCert = Rcac.fromTlv(rcac);
+            const nocCert = Noc.fromTlv(noc);
+            const icaCert = icac ? Icac.fromTlv(icac) : undefined;
+            if (icaCert !== undefined) {
+                await icaCert.verify(crypto, rootCert);
+            }
+            await nocCert.verify(crypto, rootCert, icaCert);
+        } catch (error) {
+            CryptoError.accept(error);
+            logger.error("Could not verify VendorId", error);
+            return false;
+        }
+
+        if (vidVerificationStatement) {
+            const {
+                signerSkid,
+                version: vidStatementVersion,
+                signature: vidStatementSignature,
+            } = parseStatement(vidVerificationStatement);
+
+            if (vidStatementSignature === undefined) {
+                throw new UnexpectedDataError("VID Verification Statement is missing signature");
+            }
+
+            let vvscCert: Vvsc;
+            if (vvsc !== undefined) {
+                vvscCert = Vvsc.fromTlv(vvsc);
+            } else {
+                // TODO Fetch VVSC from DCL if needed
+                // Otherwise, look up the entry in the Operational Trust Anchors Schema
+                // under the expected VendorID (VID field) being verified whose IsVIDVerificationSigner
+                // field is true and whose SubjectKeyID matches the vid_verification_signer_skid
+                // field value as the VIDVerificationSignerCertificate.
+                // TODO Fail if not available!
+                return true;
+            }
+            const {
+                extensions: { subjectKeyIdentifier },
+                ellipticCurvePublicKey,
+            } = vvscCert.cert;
+            if (!Bytes.areEqual(subjectKeyIdentifier, signerSkid)) {
+                throw new UnexpectedDataError(
+                    `VVSC SubjectKeyIdentifier does not match signerSkid in VID Verification Statement`,
+                );
+            }
+
+            // TODO Gather and Verify the VVSC cert chain using trusted root
+            // Validate the path of VIDVerificationSignerCertificate using the certificates in the Operational
+            // Trust Anchors Schema under the expected VendorID (VID field) being verified. If
+            // the path is invalid (e.g. any element of the chain missing, any certificate malformed, any
+            // signature verification fails, etc), then the procedure terminates as failed. Only the self-
+            // signed certificates among the set SHALL be considered as trust anchors during certificate
+            // path validation. The path length SHALL NOT be longer than 3. The verifier MAY
+            // apply knowledge of revoked entities obtained from outside the Distributed Compliance
+            // Ledger.
+            await vvscCert.verify(crypto);
+
+            const ourStatement = createStatementBytes({
+                version: vidStatementVersion,
+                fabricBindingMessage: tbs,
+                signerSkid,
+            });
+
+            await crypto.verifyEcdsa(PublicKey(ellipticCurvePublicKey), ourStatement, vidStatementSignature);
+        } else {
+            // TODO
+            // Look-up the entry in the Operational Trust Anchors Schema under the expected VendorID
+            // (VID field) being verified whose IsRoot field is true and whose SubjectKeyID matches the
+            // SubjectKeyID field value of the TrustedRootCertificates attribute entry whose FabricIndex
+            // field matches the fabric being verified (i.e. the RCAC of the candidate fabric). If a
+            // matching RCAC certificate is not found or empty after this step, then the procedure terminates
+            // as failed. If found, save the certificate as GloballyTrustedRoot
+            // then: Verify that the NOC chain is valid using Crypto_VerifyChain() against the entire chain
+            // reconstructed from the NOCs attribute entry whose FabricIndex field matches the fabric
+            // being verified, but populating the trusted root with the GloballyTrustedRoot certificate
+            // rather than the value in TrustedRootCertificates associated with the candidate fabric. If
+            // the chain is not valid, the procedure terminates as failed.
+        }
+
+        return true;
+    }
+
+    export function createStatementBytes(options: {
+        version?: number;
+        fabricBindingMessage: Bytes;
+        signerSkid: Bytes;
+    }) {
+        const { version = VERIFICATION_STATEMENT_VERSION, fabricBindingMessage, signerSkid } = options;
+        const writer = new DataWriter();
+        writer.writeUInt8(version);
+        writer.writeByteArray(fabricBindingMessage);
+        writer.writeByteArray(signerSkid);
+        return writer.toByteArray();
+    }
+
+    export function parseStatement(statement: Bytes) {
+        const reader = new DataReader(statement);
+        const version = reader.readUInt8();
+        if (version !== VERIFICATION_STATEMENT_VERSION) {
+            throw new UnexpectedDataError(`Unsupported VID Verification Statement version ${version}`);
+        }
+        const fabricBindingMessage = reader.readByteArray(FABRIC_BINDING_MESSAGE_SIZE);
+        const signerSkid = reader.readByteArray(20);
+        const signature = reader.remainingBytesCount > 0 ? reader.remainingBytes : undefined;
+        return {
+            version,
+            fabricBindingMessage,
+            signerSkid,
+            signature,
+        };
+    }
+}

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

@@ -10,3 +10,4 @@ export * from "./OperationalCredentialsInterface.js";
 export * from "./OperationalCredentialsBehavior.js";
 export * from "./OperationalCredentialsServer.js";
 export * from "./OperationalCredentialsClient.js";
+export * from "./VendorIdVerification.js";

package/src/behaviors/operational-state/OperationalStateClient.ts

@@ -6,10 +6,11 @@
 
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
-import { OperationalStateBehavior } from "./OperationalStateBehavior.js";
+import { OperationalState } from "#clusters/operational-state";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const OperationalStateClientConstructor = OperationalStateBehavior;
-export interface OperationalStateClient extends OperationalStateBehavior {}
+export const OperationalStateClientConstructor = ClientBehavior(OperationalState.Complete);
+export interface OperationalStateClient extends InstanceType<typeof OperationalStateClientConstructor> {}
 export interface OperationalStateClientConstructor extends Identity<typeof OperationalStateClientConstructor> {}
 export const OperationalStateClient: OperationalStateClientConstructor = OperationalStateClientConstructor;

package/src/behaviors/operational-state/OperationalStateInterface.ts

@@ -47,7 +47,7 @@ export namespace OperationalStateInterface {
          *
          * ### Table 3. Pause Compatibility
          *
-         * @see {@link MatterSpecification.v141.Cluster} § 1.14.6.1
+         * @see {@link MatterSpecification.v142.Cluster} § 1.14.6.1
          */
         pause(): MaybePromise<OperationalState.OperationalCommandResponse>;
 
@@ -71,7 +71,7 @@ export namespace OperationalStateInterface {
          *
          *   • The device shall respond with an OperationalCommandResponse command with an ErrorStateID of NoError.
          *
-         * @see {@link MatterSpecification.v141.Cluster} § 1.14.6.2
+         * @see {@link MatterSpecification.v142.Cluster} § 1.14.6.2
          */
         stop(): MaybePromise<OperationalState.OperationalCommandResponse>;
 
@@ -97,7 +97,7 @@ export namespace OperationalStateInterface {
          *
          *   • The device shall respond with an OperationalCommandResponse command with an ErrorStateID of NoError.
          *
-         * @see {@link MatterSpecification.v141.Cluster} § 1.14.6.3
+         * @see {@link MatterSpecification.v142.Cluster} § 1.14.6.3
          */
         start(): MaybePromise<OperationalState.OperationalCommandResponse>;
 
@@ -138,7 +138,7 @@ export namespace OperationalStateInterface {
          *
          *   • The device shall respond with an OperationalCommandResponse command with an ErrorStateID of NoError.
          *
-         * @see {@link MatterSpecification.v141.Cluster} § 1.14.6.4
+         * @see {@link MatterSpecification.v142.Cluster} § 1.14.6.4
          */
         resume(): MaybePromise<OperationalState.OperationalCommandResponse>;
     }

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

@@ -6,10 +6,11 @@
 
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
-import { OtaSoftwareUpdateProviderBehavior } from "./OtaSoftwareUpdateProviderBehavior.js";
+import { OtaSoftwareUpdateProvider } from "#clusters/ota-software-update-provider";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const OtaSoftwareUpdateProviderClientConstructor = OtaSoftwareUpdateProviderBehavior;
-export interface OtaSoftwareUpdateProviderClient extends OtaSoftwareUpdateProviderBehavior {}
+export const OtaSoftwareUpdateProviderClientConstructor = ClientBehavior(OtaSoftwareUpdateProvider.Complete);
+export interface OtaSoftwareUpdateProviderClient extends InstanceType<typeof OtaSoftwareUpdateProviderClientConstructor> {}
 export interface OtaSoftwareUpdateProviderClientConstructor extends Identity<typeof OtaSoftwareUpdateProviderClientConstructor> {}
 export const OtaSoftwareUpdateProviderClient: OtaSoftwareUpdateProviderClientConstructor = OtaSoftwareUpdateProviderClientConstructor;

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

@@ -15,17 +15,17 @@ export namespace OtaSoftwareUpdateProviderInterface {
          * Upon receipt, this command shall trigger an attempt to find an updated Software Image by the OTA Provider to
          * match the OTA Requestor’s constraints provided in the payload fields.
          *
-         * @see {@link MatterSpecification.v141.Core} § 11.20.6.5.1
+         * @see {@link MatterSpecification.v142.Core} § 11.20.6.5.1
          */
         queryImage(request: OtaSoftwareUpdateProvider.QueryImageRequest): MaybePromise<OtaSoftwareUpdateProvider.QueryImageResponse>;
 
         /**
-         * @see {@link MatterSpecification.v141.Core} § 11.20.6.5.3
+         * @see {@link MatterSpecification.v142.Core} § 11.20.6.5.3
          */
         applyUpdateRequest(request: OtaSoftwareUpdateProvider.ApplyUpdateRequest): MaybePromise<OtaSoftwareUpdateProvider.ApplyUpdateResponse>;
 
         /**
-         * @see {@link MatterSpecification.v141.Core} § 11.20.6.5.5
+         * @see {@link MatterSpecification.v142.Core} § 11.20.6.5.5
          */
         notifyUpdateApplied(request: OtaSoftwareUpdateProvider.NotifyUpdateAppliedRequest): MaybePromise;
     }

package/src/behaviors/ota-software-update-requestor/OtaSoftwareUpdateRequestorClient.ts

@@ -6,10 +6,11 @@
 
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
-import { OtaSoftwareUpdateRequestorBehavior } from "./OtaSoftwareUpdateRequestorBehavior.js";
+import { OtaSoftwareUpdateRequestor } from "#clusters/ota-software-update-requestor";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const OtaSoftwareUpdateRequestorClientConstructor = OtaSoftwareUpdateRequestorBehavior;
-export interface OtaSoftwareUpdateRequestorClient extends OtaSoftwareUpdateRequestorBehavior {}
+export const OtaSoftwareUpdateRequestorClientConstructor = ClientBehavior(OtaSoftwareUpdateRequestor.Complete);
+export interface OtaSoftwareUpdateRequestorClient extends InstanceType<typeof OtaSoftwareUpdateRequestorClientConstructor> {}
 export interface OtaSoftwareUpdateRequestorClientConstructor extends Identity<typeof OtaSoftwareUpdateRequestorClientConstructor> {}
 export const OtaSoftwareUpdateRequestorClient: OtaSoftwareUpdateRequestorClientConstructor = OtaSoftwareUpdateRequestorClientConstructor;

package/src/behaviors/ota-software-update-requestor/OtaSoftwareUpdateRequestorInterface.ts

@@ -18,7 +18,7 @@ export namespace OtaSoftwareUpdateRequestorInterface {
          *
          * If the accessing fabric index is 0, this command shall fail with an UNSUPPORTED_ACCESS status code.
          *
-         * @see {@link MatterSpecification.v141.Core} § 11.20.7.6.1
+         * @see {@link MatterSpecification.v142.Core} § 11.20.7.6.1
          */
         announceOtaProvider(request: OtaSoftwareUpdateRequestor.AnnounceOtaProviderRequest): MaybePromise;
     }

package/src/behaviors/oven-cavity-operational-state/OvenCavityOperationalStateClient.ts

@@ -6,10 +6,11 @@
 
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
-import { OvenCavityOperationalStateBehavior } from "./OvenCavityOperationalStateBehavior.js";
+import { OvenCavityOperationalState } from "#clusters/oven-cavity-operational-state";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const OvenCavityOperationalStateClientConstructor = OvenCavityOperationalStateBehavior;
-export interface OvenCavityOperationalStateClient extends OvenCavityOperationalStateBehavior {}
+export const OvenCavityOperationalStateClientConstructor = ClientBehavior(OvenCavityOperationalState.Complete);
+export interface OvenCavityOperationalStateClient extends InstanceType<typeof OvenCavityOperationalStateClientConstructor> {}
 export interface OvenCavityOperationalStateClientConstructor extends Identity<typeof OvenCavityOperationalStateClientConstructor> {}
 export const OvenCavityOperationalStateClient: OvenCavityOperationalStateClientConstructor = OvenCavityOperationalStateClientConstructor;

package/src/behaviors/oven-cavity-operational-state/OvenCavityOperationalStateInterface.ts

@@ -12,12 +12,12 @@ import { OvenCavityOperationalState } from "#clusters/oven-cavity-operational-st
 export namespace OvenCavityOperationalStateInterface {
     export interface Base {
         /**
-         * @see {@link MatterSpecification.v141.Cluster} § 8.10.5
+         * @see {@link MatterSpecification.v142.Cluster} § 8.10.5
          */
         stop(): MaybePromise<OvenCavityOperationalState.OperationalCommandResponse>;
 
         /**
-         * @see {@link MatterSpecification.v141.Cluster} § 8.10.5
+         * @see {@link MatterSpecification.v142.Cluster} § 8.10.5
          */
         start(): MaybePromise<OvenCavityOperationalState.OperationalCommandResponse>;
     }

package/src/behaviors/oven-mode/OvenModeClient.ts

@@ -6,10 +6,11 @@
 
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
-import { OvenModeBehavior } from "./OvenModeBehavior.js";
+import { OvenMode } from "#clusters/oven-mode";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const OvenModeClientConstructor = OvenModeBehavior;
-export interface OvenModeClient extends OvenModeBehavior {}
+export const OvenModeClientConstructor = ClientBehavior(OvenMode.Complete);
+export interface OvenModeClient extends InstanceType<typeof OvenModeClientConstructor> {}
 export interface OvenModeClientConstructor extends Identity<typeof OvenModeClientConstructor> {}
 export const OvenModeClient: OvenModeClientConstructor = OvenModeClientConstructor;

package/src/behaviors/ozone-concentration-measurement/OzoneConcentrationMeasurementClient.ts

@@ -7,11 +7,10 @@
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
 import { OzoneConcentrationMeasurement } from "#clusters/ozone-concentration-measurement";
-import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const OzoneConcentrationMeasurementClientConstructor = ClusterBehavior
-    .for(OzoneConcentrationMeasurement.Complete);
+export const OzoneConcentrationMeasurementClientConstructor = ClientBehavior(OzoneConcentrationMeasurement.Complete);
 export interface OzoneConcentrationMeasurementClient extends InstanceType<typeof OzoneConcentrationMeasurementClientConstructor> {}
 export interface OzoneConcentrationMeasurementClientConstructor extends Identity<typeof OzoneConcentrationMeasurementClientConstructor> {}
 export const OzoneConcentrationMeasurementClient: OzoneConcentrationMeasurementClientConstructor = OzoneConcentrationMeasurementClientConstructor;

package/src/behaviors/pm1-concentration-measurement/Pm1ConcentrationMeasurementClient.ts

@@ -7,10 +7,10 @@
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
 import { Pm1ConcentrationMeasurement } from "#clusters/pm1-concentration-measurement";
-import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const Pm1ConcentrationMeasurementClientConstructor = ClusterBehavior.for(Pm1ConcentrationMeasurement.Complete);
+export const Pm1ConcentrationMeasurementClientConstructor = ClientBehavior(Pm1ConcentrationMeasurement.Complete);
 export interface Pm1ConcentrationMeasurementClient extends InstanceType<typeof Pm1ConcentrationMeasurementClientConstructor> {}
 export interface Pm1ConcentrationMeasurementClientConstructor extends Identity<typeof Pm1ConcentrationMeasurementClientConstructor> {}
 export const Pm1ConcentrationMeasurementClient: Pm1ConcentrationMeasurementClientConstructor = Pm1ConcentrationMeasurementClientConstructor;

package/src/behaviors/pm10-concentration-measurement/Pm10ConcentrationMeasurementClient.ts

@@ -7,10 +7,10 @@
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
 import { Pm10ConcentrationMeasurement } from "#clusters/pm10-concentration-measurement";
-import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const Pm10ConcentrationMeasurementClientConstructor = ClusterBehavior.for(Pm10ConcentrationMeasurement.Complete);
+export const Pm10ConcentrationMeasurementClientConstructor = ClientBehavior(Pm10ConcentrationMeasurement.Complete);
 export interface Pm10ConcentrationMeasurementClient extends InstanceType<typeof Pm10ConcentrationMeasurementClientConstructor> {}
 export interface Pm10ConcentrationMeasurementClientConstructor extends Identity<typeof Pm10ConcentrationMeasurementClientConstructor> {}
 export const Pm10ConcentrationMeasurementClient: Pm10ConcentrationMeasurementClientConstructor = Pm10ConcentrationMeasurementClientConstructor;

package/src/behaviors/pm25-concentration-measurement/Pm25ConcentrationMeasurementClient.ts

@@ -7,10 +7,10 @@
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
 import { Pm25ConcentrationMeasurement } from "#clusters/pm25-concentration-measurement";
-import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const Pm25ConcentrationMeasurementClientConstructor = ClusterBehavior.for(Pm25ConcentrationMeasurement.Complete);
+export const Pm25ConcentrationMeasurementClientConstructor = ClientBehavior(Pm25ConcentrationMeasurement.Complete);
 export interface Pm25ConcentrationMeasurementClient extends InstanceType<typeof Pm25ConcentrationMeasurementClientConstructor> {}
 export interface Pm25ConcentrationMeasurementClientConstructor extends Identity<typeof Pm25ConcentrationMeasurementClientConstructor> {}
 export const Pm25ConcentrationMeasurementClient: Pm25ConcentrationMeasurementClientConstructor = Pm25ConcentrationMeasurementClientConstructor;

package/src/behaviors/power-source/PowerSourceClient.ts

@@ -7,10 +7,10 @@
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 
 import { PowerSource } from "#clusters/power-source";
-import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
 import { Identity } from "#general";
 
-export const PowerSourceClientConstructor = ClusterBehavior.for(PowerSource.Complete);
+export const PowerSourceClientConstructor = ClientBehavior(PowerSource.Complete);
 export interface PowerSourceClient extends InstanceType<typeof PowerSourceClientConstructor> {}
 export interface PowerSourceClientConstructor extends Identity<typeof PowerSourceClientConstructor> {}
 export const PowerSourceClient: PowerSourceClientConstructor = PowerSourceClientConstructor;