@matter/types 0.11.0-alpha.0-20241005-e3e4e4a7a

package/src/datatype/FabricId.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Branded, toBigInt } from "#general";
+import { TlvUInt64 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+
+/**
+ * A Fabric ID is a 64-bit number that uniquely identifies the Fabric within the scope of
+ * a particular root CA.
+ *
+ * @see {@link MatterSpecification.v10.Core} § 2.5.1
+ */
+export type FabricId = Branded<bigint, "FabricId">;
+
+export function FabricId(value: bigint | number): FabricId {
+    return toBigInt(value) as FabricId;
+}
+
+/** Tlv schema for a Node Identifier. */
+export const TlvFabricId = new TlvWrapper<FabricId, number | bigint>(
+    TlvUInt64,
+    fabricId => fabricId,
+    value => FabricId(value),
+);

package/src/datatype/FabricIndex.ts

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Branded } from "#general";
+import { TlvUInt8 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+
+/**
+ * Each fabric supported on a node is referenced by fabric-index that is unique on the node. This
+ * fabric-index enables the look-up of the full fabric information from the fabric-index. A fabric-index
+ * of 0 (zero) or null SHALL indicate that there is no fabric associated with the context in which the
+ * fabric-index is being used. If fabric-index is used in a context that is exclusively associated with
+ * a fabric, such as fabric-scoped data model elements, then the fabric-index values SHALL NOT include 0
+ * (zero) or null.
+ *
+ * @see {@link MatterSpecification.v10.Core} § 7.5.2
+ */
+export type FabricIndex = Branded<number, "FabricIndex">;
+
+export function FabricIndex(value: number): FabricIndex {
+    return value as FabricIndex;
+}
+
+export namespace FabricIndex {
+    export const NO_FABRIC = 0 as FabricIndex;
+    export const OMIT_FABRIC = -1 as FabricIndex;
+}
+
+class FabricIndexTlvWrapper extends TlvWrapper<FabricIndex, number | undefined> {
+    constructor() {
+        super(
+            TlvUInt8.bound({ min: 0, max: 254 }),
+            fabricIndex => (fabricIndex === FabricIndex.OMIT_FABRIC ? undefined : fabricIndex),
+            value => {
+                switch (value) {
+                    case undefined:
+                        return FabricIndex.OMIT_FABRIC;
+                    case 0:
+                        return FabricIndex.NO_FABRIC;
+                    default:
+                        return value as FabricIndex;
+                }
+            },
+        );
+    }
+
+    override validate(value: FabricIndex): void {
+        const wrappedValue = this.wrap(value);
+        // Because the FabricIndex is omitted sometimes we do not validate id it is absent
+        if (wrappedValue !== undefined) {
+            this.underlyingSchema.validate(wrappedValue);
+        }
+    }
+}
+
+/** Tlv Schema for a Fabric Index. */
+export const TlvFabricIndex = new FabricIndexTlvWrapper();

package/src/datatype/FieldId.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Branded } from "#general";
+import { ValidationOutOfBoundsError, validatorOf } from "../common/ValidationError.js";
+import { TlvUInt32 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+import { Mei } from "./ManufacturerExtensibleIdentifier.js";
+
+/**
+ * A "field ID" is an unsigned 32-bit integer that identifies a specific field
+ * in a cluster struct type.
+ *
+ * @see {@link MatterSpecification.v11.Core} § 7.18.2.18
+ */
+export type FieldId = Branded<number, "FieldId">;
+
+export function FieldId(fieldId: number, validate = true): FieldId {
+    if (!validate) {
+        return fieldId as FieldId;
+    }
+    if (fieldId >= 0xe0 && fieldId <= 0xfe) {
+        // Global
+        return fieldId as FieldId;
+    }
+    const { typeSuffix } = Mei.fromMei(fieldId);
+    if (typeSuffix >= 0x00 && typeSuffix <= 0xdf) {
+        return fieldId as FieldId;
+    }
+    throw new ValidationOutOfBoundsError(`Invalid field ID: ${fieldId}`);
+}
+
+export namespace FieldId {
+    export const isGlobal = (fieldId: number): boolean => {
+        return fieldId >= 0xe0 && fieldId <= 0xfe;
+    };
+
+    export const isValid = validatorOf(FieldId);
+}
+
+// TODO Adjust how to encode Field IDs
+//  Field IDs SHALL be encoded as:
+//    • A context tag when the MEI prefix encodes a standard/scoped source.
+//    • A fully-qualified profile-specific tag when the MEI prefix encodes a manufacturer code. The Vendor ID SHALL be
+//      set to the manufacturer code, the profile number set to 0 and the tag number set to the MEI suffix.
+//  NOTE Support for encoding Field IDs with an MC source is provisional.
+/** TLV schema for a field ID. */
+export const TlvFieldId = new TlvWrapper<FieldId, number>(
+    TlvUInt32,
+    fieldId => fieldId,
+    value => FieldId(value, false), // No automatic validation on decode
+);

package/src/datatype/GroupId.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Branded } from "#general";
+import { ValidationOutOfBoundsError, validatorOf } from "../common/ValidationError.js";
+import { TlvUInt16 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+
+/**
+ * A Group Identifier (Group ID or GID) is a 16-bit number that identifies a set of Nodes across a
+ * Fabric at the message layer (see Section 4.15, “Group Key Management”). A Group ID can further
+ * be bound to one or more Endpoints within each Node in the group at the interaction layer.
+ *
+ * The Group ID space is allocated as described in Table 2, “Group ID Allocations”:
+ * 0x0000 - Null or unspecified Group ID
+ * 0x0001 - 0xFEFF: Application Group ID, assigned by fabric Administrator
+ * 0xFF00 - 0xFFFF: Universal Group ID range reserved for static multicast and anycast identifiers
+ *
+ * @see {@link MatterSpecification.v10.Core} § 2.5.4
+ */
+export type GroupId = Branded<number, "GroupId">;
+
+export function GroupId(groupId: number | bigint, validate = true): GroupId {
+    if (!validate || (groupId >= 0x0000 && groupId <= 0xffff)) {
+        return Number(groupId) as GroupId;
+    }
+    throw new ValidationOutOfBoundsError(`Invalid group ID: ${groupId}`);
+}
+
+export namespace GroupId {
+    export const UNSPECIFIED_GROUP_ID = GroupId(0);
+
+    export const isValid = validatorOf(GroupId);
+}
+
+/** Tlv Schema for a Group Id. */
+export const TlvGroupId = new TlvWrapper<GroupId, number>(
+    TlvUInt16,
+    groupId => groupId,
+    value => GroupId(value, false), // No automatic validation on decode
+);

package/src/datatype/ManufacturerExtensibleIdentifier.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ValidationOutOfBoundsError } from "../common/ValidationError.js";
+import { VendorId } from "./VendorId.js";
+
+export namespace Mei {
+    /** Create a Manufacturer Extensible Identifier (MEI) from a vendor prefix and type suffix. */
+    export const asMei = (vendorPrefix: VendorId, typeSuffix: number) => {
+        if (vendorPrefix < 0 || vendorPrefix > 0xfff4) {
+            throw new ValidationOutOfBoundsError(`Invalid vendor prefix for MEI: ${vendorPrefix}`);
+        }
+        if (typeSuffix < 0 || typeSuffix > 0xfffe) {
+            throw new ValidationOutOfBoundsError(`Invalid type suffix for MEI: ${typeSuffix}`);
+        }
+
+        return ((vendorPrefix << 16) + typeSuffix) >>> 0;
+    };
+
+    /** Extract the vendor prefix and type suffix from a Manufacturer Extensible Identifier (MEI). */
+    export const fromMei = (mei: number): { vendorPrefix: VendorId; typeSuffix: number } => {
+        const vendorPrefix = mei >>> 16;
+        if (vendorPrefix > 0xfff4) {
+            throw new ValidationOutOfBoundsError(`Invalid vendor prefix for MEI: ${mei}`);
+        }
+
+        const typeSuffix = mei & 0xffff;
+        if (typeSuffix > 0xfffe) {
+            throw new ValidationOutOfBoundsError(`Invalid type suffix for MEI: ${mei}`);
+        }
+
+        return {
+            vendorPrefix: VendorId(vendorPrefix),
+            typeSuffix: mei & 0xffff,
+        };
+    };
+
+    /**
+     * Check if the MEI has a custom vendor prefix.
+     *
+     * @param mei The MEI to check.
+     * @param vendorPrefix An optional vendor prefix to check against. if not provided, checks if the prefix is not equal 0
+     */
+    export const hasCustomMeiPrefix = (mei: number, vendorPrefix?: VendorId) => {
+        if (vendorPrefix === undefined) {
+            return mei > 0xfffe;
+        }
+        return mei >>> 16 === vendorPrefix;
+    };
+}

package/src/datatype/NodeId.ts

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Branded, Bytes, Crypto, DataWriter, Endian, toBigInt, UnexpectedDataError } from "#general";
+import { TlvUInt64 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+import { CaseAuthenticatedTag } from "./CaseAuthenticatedTag.js";
+
+/**
+ * A Node Identifier (Node ID) is a 64-bit number that uniquely identifies an individual Node or a
+ * group of Nodes on a Fabric.
+ *
+ * @see {@link MatterSpecification.v10.Core} § 2.5.5
+ */
+export type NodeId = Branded<bigint, "NodeId">;
+
+export function NodeId(v: bigint | number): NodeId {
+    return toBigInt(v) as NodeId;
+}
+
+export namespace NodeId {
+    const OPERATIONAL_NODE_MIN = BigInt("0x0000000000000001");
+    const OPERATIONAL_NODE_MAX = BigInt("0xFFFFFFEFFFFFFFFF");
+
+    /**
+     * The Unspecified Node ID (0x0000_0000_0000_0000) is a reserved value that never appears in messages or protocol
+     * usage. It exists to mark or detect the presence of uninitialized, missing, or invalid Node IDs.
+     */
+    export const UNSPECIFIED_NODE_ID = NodeId(0);
+
+    export const toHexString = (nodeId: NodeId) => {
+        const writer = new DataWriter(Endian.Big);
+        writer.writeUInt64(nodeId);
+        return Bytes.toHex(writer.toByteArray()).toUpperCase();
+    };
+
+    /**
+     * An Operational Node ID is a 64-bit number that uniquely identifies an individual Node on a Fabric. All messages
+     * must have an Operational Node ID as the source address. All unicast messages must have an Operational Node ID
+     * as the destination address.
+     */
+    export const randomOperationalNodeId = (): NodeId => {
+        while (true) {
+            const randomBigInt = Crypto.getRandomBigInt(8);
+            if (randomBigInt >= OPERATIONAL_NODE_MIN && randomBigInt <= OPERATIONAL_NODE_MAX) {
+                return NodeId(randomBigInt);
+            }
+        }
+    };
+
+    /**
+     * Returns whether the given Node ID is an Operational Node ID.
+     */
+    export const isOperationalNodeId = (nodeId: NodeId): boolean => {
+        return nodeId >= OPERATIONAL_NODE_MIN && nodeId <= OPERATIONAL_NODE_MAX;
+    };
+
+    /** A Group Node ID is a 64-bit Node ID that contains a particular Group ID in the lower half of the Node ID. */
+    export const fromGroupNodeId = (groupId: number): NodeId => {
+        if (groupId < 0 || groupId > 0xffff) {
+            throw new UnexpectedDataError(`Invalid group ID: ${groupId}`);
+        }
+        return NodeId(BigInt("0xFFFFFFFFFFFF" + groupId.toString(16).padStart(4, "0")));
+    };
+
+    /**
+     * A Temporary Local Node ID is a 64-bit Node ID that contains an implementation-dependent value in its lower
+     * 32 bits. This allows implementations to keep track of connections or transport-layer links and similar
+     * housekeeping internal usage purposes in contexts where an Operational Node ID is unavailable.
+     */
+    export const fromTemporaryLocalNodeId = (id: number): NodeId => {
+        if (id < 0 || id > 0xffffffff) {
+            throw new UnexpectedDataError(`Invalid ID: ${id}`);
+        }
+        return NodeId(BigInt("0xFFFFFFFE" + id.toString(16).padStart(8, "0")));
+    };
+
+    /**
+     * This subrange of Node ID is used to assign an access control subject to a group of peer nodes that share a
+     * single CASE session as specified in Section 6.6.2.1.2, “Subjects identified by CASE Authenticated Tag”.
+     */
+    export const fromCaseAuthenticatedTag = (id: CaseAuthenticatedTag): NodeId => {
+        if (id < 0 || id > 0xffffffff) {
+            throw new UnexpectedDataError(`Invalid CASE Authenticated tag: ${id}`);
+        }
+        return NodeId(BigInt("0xFFFFFFFD" + id.toString(16).padStart(8, "0")));
+    };
+
+    export const isCaseAuthenticatedTag = (nodeId: NodeId): boolean => {
+        const nodeIdHex = nodeId.toString(16);
+        return nodeIdHex.startsWith("fffffffd") && nodeIdHex.length === 16;
+    };
+
+    export const extractAsCaseAuthenticatedTag = (nodeId: NodeId): CaseAuthenticatedTag => {
+        if (!isCaseAuthenticatedTag(nodeId)) {
+            throw new UnexpectedDataError(`Invalid CASE Authenticated tag: ${nodeId}`);
+        }
+        return CaseAuthenticatedTag(parseInt(nodeId.toString(16).slice(8), 16));
+    };
+
+    /**
+     * This subrange of Node ID is used to assign an access control subject to a particular PAKE key as specified in
+     * Section 6.6.2.1.1, “PASE and Group Subjects”. An example usage would be to create an ACL entry to provide
+     * administrative access to any commissioner communicating via a PASE session established with a particular pincode.
+     */
+    export const getFromPakeKeyIdentifier = (id: number): NodeId => {
+        if (id < 0 || id > 0xffffffff) {
+            throw new UnexpectedDataError(`Invalid ID: ${id}`);
+        }
+        return NodeId(BigInt("0xFFFFFFFB" + id.toString(16).padStart(8, "0")));
+    };
+}
+
+/** Tlv schema for a Node Identifier. */
+export const TlvNodeId = new TlvWrapper<NodeId, number | bigint>(
+    TlvUInt64,
+    nodeId => nodeId,
+    value => NodeId(BigInt(value)),
+);

package/src/datatype/SubjectId.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { NodeId, TlvNodeId } from "./NodeId.js";
+
+/**
+ * The meaning of a "Subject" is primarily that of describing the source for an action, using a given
+ * authentication method provided by the Secure Channel architecture.
+ *
+ * @see {@link MatterSpecification.v10.Core} § 6.6.2.1
+ */
+export type SubjectId = NodeId; // Only NodeId is supported for now...
+
+/** Tlv schema for a Subject Id */
+export const TlvSubjectId = TlvNodeId;

package/src/datatype/VendorId.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Branded } from "#general";
+import { ValidationOutOfBoundsError } from "../common/ValidationError.js";
+import { TlvUInt16 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+
+/**
+ * A Vendor Identifier (Vendor ID or VID) is a 16-bit number that uniquely identifies a particular
+ * product manufacturer, vendor, or group thereof. Each Vendor ID is statically allocated by the
+ * Connectivity Standards Alliance (see [CSA Manufacturer Code Database]).
+ *
+ * @see {@link MatterSpecification.v10.Core} § 2.5.2
+ */
+export type VendorId = Branded<number, "VendorId">;
+
+export function VendorId(vendorId: number, validate = true): VendorId {
+    if (!validate || (vendorId >= 0 && vendorId <= 0xfff4)) {
+        return vendorId as VendorId;
+    }
+    throw new ValidationOutOfBoundsError(`Invalid vendor ID: ${vendorId}`);
+}
+
+export namespace VendorId {
+    export const isValid = (v: number): v is VendorId => {
+        try {
+            VendorId(v);
+            return true;
+        } catch {
+            return false;
+        }
+    };
+}
+
+/** Data model for a Vendor Identifier. */
+export const TlvVendorId = new TlvWrapper<VendorId, number>(
+    TlvUInt16,
+    vendorId => vendorId,
+    value => VendorId(value, false), // No automatic validation on decode
+);

package/src/datatype/index.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from "./AttributeId.js";
+export * from "./CaseAuthenticatedTag.js";
+export * from "./ClusterId.js";
+export * from "./CommandId.js";
+export * from "./DataVersion.js";
+export * from "./DeviceTypeId.js";
+export * from "./EndpointNumber.js";
+export * from "./EntryIndex.js";
+export * from "./EventId.js";
+export * from "./EventNumber.js";
+export * from "./FabricId.js";
+export * from "./FabricIndex.js";
+export * from "./FieldId.js";
+export * from "./GroupId.js";
+export * from "./ManufacturerExtensibleIdentifier.js";
+export * from "./NodeId.js";
+export * from "./SubjectId.js";
+export * from "./VendorId.js";

package/src/globals/MeasurementAccuracy.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { TlvField, TlvObject } from "../tlv/TlvObject.js";
+import { MeasurementType } from "./MeasurementType.js";
+import { TlvEnum, TlvInt64 } from "../tlv/TlvNumber.js";
+import { TlvBoolean } from "../tlv/TlvBoolean.js";
+import { TlvArray } from "../tlv/TlvArray.js";
+import { TlvMeasurementAccuracyRange } from "./MeasurementAccuracyRange.js";
+import { TypeFromSchema } from "../tlv/TlvSchema.js";
+
+/**
+ * This struct represents the set of accuracy ranges for a given measurement, the maximum and minimum values for the
+ * measurement, and whether the measurement is directly measured or just estimated from other information.
+ *
+ * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.4
+ */
+export const TlvMeasurementAccuracy = TlvObject({
+    /**
+     * This field shall indicate the type of measurement for the accuracy provided.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.4.1
+     */
+    measurementType: TlvField(0, TlvEnum<MeasurementType>()),
+
+    /**
+     * This field shall indicate whether the associated measurement was directly measured. If this field is not set to
+     * true, then the associated measurement was estimated.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.4.2
+     */
+    measured: TlvField(1, TlvBoolean),
+
+    minMeasuredValue: TlvField(2, TlvInt64),
+    maxMeasuredValue: TlvField(3, TlvInt64),
+
+    /**
+     * This field shall indicate a list of measurement ranges and their associated accuracies.
+     *
+     * The value of the RangeMin field on the first MeasurementAccuracyRangeStruct in this list shall be equal to the
+     * value of the MinMeasuredValue field.
+     *
+     * The value of the RangeMax field on the last MeasurementAccuracyRangeStruct in this list shall be less than or
+     * equal to the value of the MaxMeasuredValue field.
+     *
+     * The value of the RangeMin field on each MeasurementAccuracyRangeStruct in this list other than the first shall
+     * be one more the value of the RangeMax field on the previous MeasurementAccuracyRangeStruct in this list (i.e.
+     * there shall be no gaps in the accuracy ranges, and the ranges shall be in increasing order).
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.4.5
+     */
+    accuracyRanges: TlvField(4, TlvArray(TlvMeasurementAccuracyRange, { minLength: 1 }))
+});
+
+/**
+ * This struct represents the set of accuracy ranges for a given measurement, the maximum and minimum values for the
+ * measurement, and whether the measurement is directly measured or just estimated from other information.
+ *
+ * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.4
+ */
+export interface MeasurementAccuracy extends TypeFromSchema<typeof TlvMeasurementAccuracy> {}

package/src/globals/MeasurementAccuracyRange.ts

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { TlvField, TlvOptionalField, TlvObject } from "../tlv/TlvObject.js";
+import { TlvInt64, TlvPercent100ths, TlvUInt64 } from "../tlv/TlvNumber.js";
+import { TypeFromSchema } from "../tlv/TlvSchema.js";
+
+/**
+ * This struct represents the accuracy of a measurement for a range of measurement values. Accuracy shall be expressed
+ * as a maximum +/- percentage of the true value, a maximum +/- fixed value of the true value, or both.
+ *
+ *   • If both PercentMax and FixedMax are indicated, then for a given true value in the range between RangeMin and
+ *     RangeMax,
+ *
+ *     ◦ the reported value shall be less than or equal to the sum of the true value, FixedMax and PercentMax percent
+ *       of the true value.
+ *
+ *     ◦ the reported value shall be greater than or equal to the true value minus the sum of FixedMax and PercentMax
+ *       percent of the true value.
+ *
+ *   • If only PercentMax is indicated, then for a given true value in the range between RangeMin and RangeMax,
+ *
+ *     ◦ the reported value shall be less than or equal to the sum of the true value and PercentMax percent of the true
+ *       value.
+ *
+ *     ◦ the reported value shall be greater than or equal to the true value minus PercentMax per
+ *
+ * cent of the true value.
+ *
+ *   • If only FixedMax is indicated, then for a given true value in the range between RangeMin and RangeMax,
+ *
+ *     ◦ the reported value shall be less than or equal to the sum of the true value and FixedMax.
+ *
+ *     ◦ the reported value shall be greater than or equal to the true value minus FixedMax.
+ *
+ * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3
+ */
+export const TlvMeasurementAccuracyRange = TlvObject({
+    /**
+     * This field shall indicate the minimum measurement value for the specified level of accuracy.
+     *
+     * The value of this field shall be greater than or equal to the value of the MinMeasuredValue field on the
+     * encompassing MeasurementAccuracyStruct.
+     *
+     * The value of this field shall be less than or equal to the value of the MaxMeasuredValue field on the
+     * encompassing MeasurementAccuracyStruct.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3.1
+     */
+    rangeMin: TlvField(0, TlvInt64),
+
+    /**
+     * This field shall indicate the maximum measurement value for the specified level of accuracy. The value of this
+     * field shall be greater than the value of the RangeMin field.
+     *
+     * The value of this field shall be greater than or equal to the value of the MinMeasuredValue field on the
+     * encompassing MeasurementAccuracyStruct.
+     *
+     * The value of this field shall be less than or equal to the value of the MaxMeasuredValue field on the
+     * encompassing MeasurementAccuracyStruct.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3.2
+     */
+    rangeMax: TlvField(1, TlvInt64),
+
+    /**
+     * This field shall indicate the maximum +/- percentage accuracy for the associated measurement.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3.3
+     */
+    percentMax: TlvOptionalField(2, TlvPercent100ths),
+
+    /**
+     * This field shall indicate the minimum +/- percentage accuracy for the associated measurement.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3.4
+     */
+    percentMin: TlvOptionalField(3, TlvPercent100ths),
+
+    /**
+     * This field shall indicate the typical +/- percentage accuracy for the associated measurement.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3.5
+     */
+    percentTypical: TlvOptionalField(4, TlvPercent100ths),
+
+    /**
+     * This field shall indicate the maximum +/- fixed accuracy for the associated measurement, in the unit indicated
+     * by MeasurementType.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3.6
+     */
+    fixedMax: TlvOptionalField(5, TlvUInt64),
+
+    /**
+     * This field shall indicate the minimum +/- fixed accuracy for the associated measurement, in the unit indicated
+     * by MeasurementType.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3.7
+     */
+    fixedMin: TlvOptionalField(6, TlvUInt64),
+
+    /**
+     * This field shall indicate the typical +/- fixed accuracy for the associated measurement, in the unit indicated
+     * by MeasurementType.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3.8
+     */
+    fixedTypical: TlvOptionalField(7, TlvUInt64)
+});
+
+/**
+ * This struct represents the accuracy of a measurement for a range of measurement values. Accuracy shall be expressed
+ * as a maximum +/- percentage of the true value, a maximum +/- fixed value of the true value, or both.
+ *
+ *   • If both PercentMax and FixedMax are indicated, then for a given true value in the range between RangeMin and
+ *     RangeMax,
+ *
+ *     ◦ the reported value shall be less than or equal to the sum of the true value, FixedMax and PercentMax percent
+ *       of the true value.
+ *
+ *     ◦ the reported value shall be greater than or equal to the true value minus the sum of FixedMax and PercentMax
+ *       percent of the true value.
+ *
+ *   • If only PercentMax is indicated, then for a given true value in the range between RangeMin and RangeMax,
+ *
+ *     ◦ the reported value shall be less than or equal to the sum of the true value and PercentMax percent of the true
+ *       value.
+ *
+ *     ◦ the reported value shall be greater than or equal to the true value minus PercentMax per
+ *
+ * cent of the true value.
+ *
+ *   • If only FixedMax is indicated, then for a given true value in the range between RangeMin and RangeMax,
+ *
+ *     ◦ the reported value shall be less than or equal to the sum of the true value and FixedMax.
+ *
+ *     ◦ the reported value shall be greater than or equal to the true value minus FixedMax.
+ *
+ * @see {@link MatterSpecification.v13.Cluster} § 2.1.4.3
+ */
+export interface MeasurementAccuracyRange extends TypeFromSchema<typeof TlvMeasurementAccuracyRange> {}