@project-chip/matter.js 0.0.2 → 0.2.0

package/dist/dts/common/EndpointNumber.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * A Endpoint Number is a 16-bit number that that indicates an instance of a device type.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 7.18.2.11
+ */
+export declare class EndpointNumber {
+    readonly number: number;
+    constructor(number: number);
+}
+/** Tlv schema for an Endpoint number. */
+export declare const TlvEndpointNumber: TlvWrapper<EndpointNumber, number>;

package/dist/dts/common/FabricId.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 MatterCoreSpecificationV1_0} § 2.5.1
+ */
+export declare class FabricId {
+    readonly id: bigint;
+    constructor(id: bigint);
+}
+/** Tlv schema for a Node Identifier. */
+export declare const TlvFabricId: TlvWrapper<FabricId, number | bigint>;

package/dist/dts/common/FabricIndex.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 MatterCoreSpecificationV1_0} § 7.5.2
+ */
+export declare class FabricIndex {
+    readonly index: number;
+    constructor(index: number);
+}
+/** Tlv Schema for a Fabric Index. */
+export declare const TlvFabricIndex: TlvWrapper<FabricIndex, number>;

package/dist/dts/common/GroupId.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 MatterCoreSpecificationV1_0} § 2.5.4
+ */
+export declare class GroupId {
+    readonly id: number;
+    constructor(id: number);
+}
+/** Tlv Schema for a Group Id. */
+export declare const TlvGroupId: TlvWrapper<GroupId, number>;

package/dist/dts/common/NodeId.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvWrapper } from "../tlv/TlvWrapper.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 MatterCoreSpecificationV1_0} § 2.5.5
+ */
+export declare class NodeId {
+    readonly id: bigint;
+    constructor(id: bigint);
+    toString(): string;
+}
+/** Tlv schema for a Node Identifier. */
+export declare const TlvNodeId: TlvWrapper<NodeId, number | bigint>;

package/dist/dts/common/SubjectId.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { NodeId } 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 MatterCoreSpecificationV1_0} § 6.6.2.1
+ */
+export type SubjectId = NodeId;
+/** Tlv schema for a Subject Id */
+export declare const TlvSubjectId: import("../matter.js").TlvWrapper<NodeId, number | bigint>;

package/dist/dts/common/VendorId.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 MatterCoreSpecificationV1_0} § 2.5.2
+ */
+export declare class VendorId {
+    readonly id: number;
+    constructor(id: number);
+}
+/** Data model for a Vendor Identifier. */
+export declare const TlvVendorId: TlvWrapper<VendorId, number>;

package/dist/{matter.d.ts → dts/matter.d.ts}

@@ -20,3 +20,15 @@ export * from "./tlv/TlvString.js";
 export * from "./tlv/TlvNumber.js";
 export * from "./tlv/TlvVoid.js";
 export * from "./tlv/TlvWrapper.js";
+export * from "./cluster/AccessControlCluster.js";
+export * from "./cluster/BasicInformationCluster.js";
+export * from "./cluster/BindingCluster.js";
+export * from "./cluster/BridgedDeviceBasicInformationCluster.js";
+export * from "./cluster/DescriptorCluster.js";
+export * from "./cluster/GeneralCommissioningCluster.js";
+export * from "./cluster/GroupsCluster.js";
+export * from "./cluster/IdentifyCluster.js";
+export * from "./cluster/LabelCluster.js";
+export * from "./cluster/OnOffCluster.js";
+export * from "./cluster/OperationalCredentialsCluster.js";
+export * from "./cluster/ScenesCluster.js";

package/dist/dts/protocol/InteractionProtocol.d.ts

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 8.10
+ */
+export declare const enum StatusCode {
+    Success = 0,
+    Failure = 1,
+    InvalidSubscription = 125,
+    UnsupportedAccess = 126,
+    UnsupportedEndpoint = 127,
+    InvalidAction = 128,
+    UnsupportedCommand = 129,
+    InvalidCommand = 133,
+    UnsupportedAttribute = 134,
+    ConstraintError = 135,
+    UnsupportedWrite = 136,
+    ResourceExhausted = 137,
+    NotFound = 139,
+    UnreportableAttribute = 140,
+    InvalidDataType = 141,
+    UnsupportedRead = 143,
+    DataVersionMismatch = 146,
+    Timeout = 148,
+    UnsupportedMode = 155,
+    Busy = 156,
+    UnsupportedCluster = 195,
+    NoUpstreamSubscription = 197,
+    NeedsTimedInteraction = 198,
+    UnsupportedEvent = 199,
+    PathsExhausted = 200,
+    TimedRequestMismatch = 201,
+    FailsafeRequired = 202
+}
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.1. StatusResponseMessage
+ */
+export declare const TlvStatusResponse: import("../tlv/TlvObject.js").ObjectSchema<{
+    status: import("../tlv/TlvObject.js").FieldType<StatusCode>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.2. ReadRequestMessage
+ */
+export declare const TlvReadRequest: import("../tlv/TlvObject.js").ObjectSchema<{
+    attributes: import("../tlv/TlvObject.js").FieldType<{
+        id?: number | undefined;
+        endpointId?: number | undefined;
+        clusterId?: number | undefined;
+    }[]>;
+    isFabricFiltered: import("../tlv/TlvObject.js").FieldType<boolean>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.3. ReportDataMessage
+ */
+export declare const TlvReportData: import("../tlv/TlvObject.js").ObjectSchema<{
+    subscriptionId: import("../tlv/TlvObject.js").OptionalFieldType<number>;
+    values: import("../tlv/TlvObject.js").FieldType<{
+        value: {
+            value: import("../matter.js").TlvStream;
+            path: {
+                id: number;
+                endpointId: number;
+                clusterId: number;
+            };
+            version: number;
+        };
+    }[]>;
+    isFabricFiltered: import("../tlv/TlvObject.js").OptionalFieldType<boolean>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.4. SubscribeRequestMessage
+ */
+export declare const TlvSubscribeRequest: import("../tlv/TlvObject.js").ObjectSchema<{
+    keepSubscriptions: import("../tlv/TlvObject.js").FieldType<boolean>;
+    minIntervalFloorSeconds: import("../tlv/TlvObject.js").FieldType<number>;
+    maxIntervalCeilingSeconds: import("../tlv/TlvObject.js").FieldType<number>;
+    attributeRequests: import("../tlv/TlvObject.js").OptionalFieldType<{
+        id?: number | undefined;
+        endpointId?: number | undefined;
+        clusterId?: number | undefined;
+    }[]>;
+    eventRequests: import("../tlv/TlvObject.js").OptionalFieldType<{
+        event: number;
+        cluster: number;
+        endpoint: number;
+        node: import("../common/NodeId.js").NodeId;
+        isUrgent: boolean;
+    }[]>;
+    eventFilters: import("../tlv/TlvObject.js").OptionalFieldType<{
+        node: import("../common/NodeId.js").NodeId;
+        eventMin: number | bigint;
+    }[]>;
+    isFabricFiltered: import("../tlv/TlvObject.js").FieldType<boolean>;
+    dataVersionFilters: import("../tlv/TlvObject.js").OptionalFieldType<{
+        path: {
+            cluster: number;
+            endpoint: number;
+            node: import("../common/NodeId.js").NodeId;
+        };
+        dataVersion: number;
+    }[]>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.5. SubscribeResponseMessage
+ */
+export declare const TlvSubscribeResponse: import("../tlv/TlvObject.js").ObjectSchema<{
+    subscriptionId: import("../tlv/TlvObject.js").FieldType<number>;
+    maxIntervalCeilingSeconds: import("../tlv/TlvObject.js").FieldType<number>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.9. InvokeRequestMessage
+ */
+export declare const TlvInvokeRequest: import("../tlv/TlvObject.js").ObjectSchema<{
+    suppressResponse: import("../tlv/TlvObject.js").FieldType<boolean>;
+    timedRequest: import("../tlv/TlvObject.js").FieldType<boolean>;
+    invokes: import("../tlv/TlvObject.js").FieldType<{
+        path: {
+            id: number;
+            endpointId: number;
+            clusterId: number;
+        };
+        args: import("../matter.js").TlvStream;
+    }[]>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.10. InvokeResponseMessage
+ */
+export declare const TlvInvokeResponse: import("../tlv/TlvObject.js").ObjectSchema<{
+    suppressResponse: import("../tlv/TlvObject.js").FieldType<boolean>;
+    responses: import("../tlv/TlvObject.js").FieldType<{
+        response?: {
+            path: {
+                id: number;
+                endpointId: number;
+                clusterId: number;
+            };
+            response: import("../matter.js").TlvStream;
+        } | undefined;
+        result?: {
+            path: {
+                id: number;
+                endpointId: number;
+                clusterId: number;
+            };
+            result: {
+                code: number;
+            };
+        } | undefined;
+    }[]>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;

package/dist/{schema → dts/schema}/BitmapSchema.d.ts

@@ -3,7 +3,8 @@
  * Copyright 2022 Project CHIP Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Schema } from "./Schema.js";
+import { ByteArray } from "../util/ByteArray";
+import { Schema } from "./Schema";
 declare const enum BitRangeType {
     Flag = 0,
     Number = 1,
@@ -12,7 +13,7 @@ declare const enum BitRangeType {
 type BitRange<T> = {
     type: BitRangeType;
     offset: number;
-    mask: number;
+    length: number;
 };
 declare const BitRange: <T>(type: BitRangeType, offset: number, length: number) => BitRange<T>;
 /** Defines the bit position of a boolean flag. */
@@ -37,11 +38,22 @@ export type TypeFromBitSchema<T extends BitSchema> = {
     [K in keyof T]: T[K] extends BitFieldEnum<infer E> ? E : (T[K] extends BitField ? number : boolean);
 };
 declare class BitmapSchemaInternal<T extends BitSchema> extends Schema<TypeFromBitSchema<T>, number> {
-    readonly bitSchemas: T;
+    private readonly bitSchemas;
+    private readonly masks;
     constructor(bitSchemas: T);
     encodeInternal(value: TypeFromBitSchema<T>): number;
     decodeInternal(bitmap: number): TypeFromBitSchema<T>;
 }
+declare class ByteArrayBitmapSchemaInternal<T extends BitSchema> extends Schema<TypeFromBitSchema<T>, ByteArray> {
+    private readonly bitSchemas;
+    private readonly byteArrayLength;
+    private readonly maskOffset;
+    constructor(bitSchemas: T);
+    encodeInternal(value: TypeFromBitSchema<T>): Uint8Array;
+    decodeInternal(bitmap: ByteArray): TypeFromBitSchema<T>;
+}
 /** Declares a bitmap schema by indicating the bit position and their names. */
 export declare const BitmapSchema: <T extends BitSchema>(bitSchemas: T) => BitmapSchemaInternal<T>;
+/** Declares a bitmap schema backed by a ByteArray by indicating the bit position and their names. */
+export declare const ByteArrayBitmapSchema: <T extends BitSchema>(bitSchemas: T) => ByteArrayBitmapSchemaInternal<T>;
 export {};

package/dist/{util → dts/util}/Type.d.ts

@@ -7,3 +7,4 @@
 export type Merge<A, B> = A & B extends infer AB ? {
     [K in keyof AB]: AB[K];
 } : never;
+export declare const Merge: <A, B>(a: A, b: B) => Merge<A, B>;

package/dist/es/cluster/AccessControlCluster.js

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Cluster, WritableAttribute, Attribute, Event, OptionalWritableAttribute } from "./Cluster.js";
+import { TlvClusterId } from "../common/ClusterId.js";
+import { TlvEndpointNumber } from "../common/EndpointNumber.js";
+import { TlvDeviceTypeId } from "../common/DeviceTypeId.js";
+import { TlvNodeId } from "../common/NodeId.js";
+import { TlvSubjectId } from "../common/SubjectId.js";
+import { TlvField, TlvObject } from "../tlv/TlvObject.js";
+import { TlvNullable } from "../tlv/TlvNullable.js";
+import { TlvEnum, TlvUInt16 } from "../tlv/TlvNumber.js";
+import { TlvArray } from "../tlv/TlvArray.js";
+import { TlvByteString } from "../tlv/TlvString.js";
+/**
+ *
+ * Defines the clusters on this Node to which this Access Control Entry grants access.
+ *
+ * A single target SHALL contain at least one field (Cluster, Endpoint, or DeviceType), and SHALL NOT
+ * contain both an Endpoint field and a DeviceType field.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.10.5.3
+ */
+const TlvTarget = TlvObject({
+    /** Cluster to grant access on. */
+    cluster: TlvField(0, TlvNullable(TlvClusterId)),
+    /** Endpoint to grant access on. */
+    endpoint: TlvField(1, TlvNullable(TlvEndpointNumber)),
+    /** Device type to grant access on. */
+    deviceType: TlvField(1, TlvNullable(TlvDeviceTypeId)),
+});
+/** @see {@link MatterCoreSpecificationV1_0} § 9.10.5.3 */
+const TlvAccessControlEntry = TlvObject({
+    /** Specifies the level of privilege granted by this Access Control Entry. */
+    privilege: TlvField(1, TlvEnum()),
+    /** Specifies the authentication mode required by this Access Control Entry. */
+    authMode: TlvField(2, TlvEnum()),
+    /** Specifies a list of Subject IDs, to which this Access Control Entry grants access. */
+    subjects: TlvField(3, TlvNullable(TlvArray(TlvSubjectId))),
+    /** Specifies a list of TargetStruct, which define the clusters on this Node to which this Access Control Entry grants access. */
+    targets: TlvField(4, TlvNullable(TlvArray(TlvTarget))), /* maxArrayLength: targetsPerAccessControlEntry */
+});
+/** @see {@link MatterCoreSpecificationV1_0} § 9.10.5.4 */
+const TlvAccessControlExtensionEntry = TlvObject({
+    /** Used by manufacturers to store arbitrary TLV-encoded data related to a fabric’s Access Control Entries. */
+    data: TlvField(1, TlvByteString.bound({ maxLength: 128 })),
+});
+/** @see {@link MatterCoreSpecificationV1_0} § 9.10.7.1 */
+const AccessChangeEvent = (entrySchema) => ({
+    /** The Node ID of the Administrator that made the change, if the change occurred via a CASE session. */
+    adminNodeID: TlvField(1, TlvNullable(TlvNodeId)),
+    /** The Passcode ID of the Administrator that made the change, if the change occurred via a PASE session. */
+    adminPasscodeID: TlvField(2, TlvNullable(TlvUInt16)),
+    /** The type of change as appropriate. */
+    changeType: TlvField(3, TlvEnum()),
+    /** The latest value of the changed entry. */
+    latestValue: TlvField(4, TlvNullable(entrySchema)),
+});
+/**
+ * The Access Control Cluster exposes a data model view of a Node’s Access Control List (ACL),
+ * which codifies the rules used to manage and enforce Access Control for the Node’s endpoints
+ * and their associated cluster instances. Access to this Access Control Cluster itself requires
+ * a special Administer privilege level, such that only Nodes granted such privilege (hereafter
+ * termed "Administrators") can manage the Access Control Cluster.
+ * The Access Control Cluster SHALL be present on the root node endpoint of each Node, and SHALL
+ * NOT be present on any other Endpoint of any Node.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.10
+ */
+export const AccessControlCluster = Cluster({
+    id: 0x1f,
+    name: "Access Control",
+    revision: 1,
+    /** @see {@link MatterCoreSpecificationV1_0} § 9.10.5 */
+    attributes: {
+        /** Codifies a single grant of privilege on this Node. */
+        acl: WritableAttribute(0, TlvArray(TlvAccessControlEntry), { default: [], writeAcl: 2 /* AccessLevel.Administer */, readAcl: 2 /* AccessLevel.Administer */ }),
+        /** MAY be used by Administrators to store arbitrary data related to fabric’s Access Control Entries. */
+        extension: OptionalWritableAttribute(1, TlvArray(TlvAccessControlExtensionEntry), { default: [], writeAcl: 2 /* AccessLevel.Administer */, readAcl: 2 /* AccessLevel.Administer */ }),
+        /** Provide the minimum number of Subjects per entry that are supported by this server. */
+        subjectsPerAccessControlEntry: Attribute(2, TlvUInt16.bound({ min: 4 }), { default: 4 }),
+        /** Provides the minimum number of Targets per entry that are supported by this server. */
+        targetsPerAccessControlEntry: Attribute(3, TlvUInt16.bound({ min: 3 }), { default: 3 }),
+        /** Provides the minimum number of ACL Entries per fabric that are supported by this server. */
+        accessControlEntriesPerFabric: Attribute(4, TlvUInt16.bound({ min: 3 }), { default: 3 }),
+    },
+    /** @see {@link MatterCoreSpecificationV1_0} § 9.10.7 */
+    events: {
+        /**
+         * The cluster SHALL send AccessControlEntryChanged events whenever its ACL attribute data is changed by an
+         * Administrator.
+         */
+        accessControlEntryChanged: Event(0, 1 /* EventPriority.Info */, AccessChangeEvent(TlvAccessControlEntry)),
+        /**
+         * The cluster SHALL send AccessControlExtensionChanged events whenever its extension attribute data is changed
+         * by an Administrator.
+         */
+        accessControlExtensionChanged: Event(1, 1 /* EventPriority.Info */, AccessChangeEvent(TlvAccessControlExtensionEntry)), /* readAcl: AccessLevel.Administer */
+    },
+});

package/dist/es/cluster/BasicInformationCluster.js

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvFabricIndex } from "../common/FabricIndex.js";
+import { TlvVendorId } from "../common/VendorId.js";
+import { TlvBoolean } from "../tlv/TlvBoolean.js";
+import { TlvUInt16, TlvUInt32 } from "../tlv/TlvNumber.js";
+import { TlvField, TlvObject } from "../tlv/TlvObject.js";
+import { TlvString, TlvString256max, TlvString32max, TlvString64max } from "../tlv/TlvString.js";
+import { Attribute, Cluster, Event, OptionalAttribute, OptionalEvent, OptionalWritableAttribute, WritableAttribute } from "./Cluster.js";
+/**
+ * Provides constant values related to overall global capabilities of this Node, that are not cluster-specific.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 11.1.6.2
+ */
+const TlvCapabilityMinima = TlvObject({
+    /** Indicates the minimum number of concurrent CASE sessions that are supported per fabric. */
+    caseSessionsPerFabric: TlvField(0, TlvUInt16.bound({ min: 3 })),
+    /** Indicate the actual minimum number of concurrent subscriptions supported per fabric. */
+    subscriptionsPerFabric: TlvField(1, TlvUInt16.bound({ min: 3 })),
+});
+/**
+ * This cluster provides attributes and events for determining basic information about Nodes, which supports both
+ * commissioning and operational determination of Node characteristics, such as Vendor ID, Product ID and serial number,
+ * which apply to the whole Node. Also allows setting user device information such as location.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 11.1
+ */
+export const BasicInformationCluster = Cluster({
+    id: 0x28,
+    name: "Basic Information",
+    revision: 1,
+    /** @see {@link MatterCoreSpecificationV1_0} § 11.1.6.3 */
+    attributes: {
+        /** Revision number of the Data Model against which the Node is certified */
+        dataModelRevision: Attribute(0, TlvUInt16),
+        /** Human-readable (displayable) name of the vendor for the Node. */
+        vendorName: Attribute(1, TlvString32max),
+        /** Specifies the {@link VendorId}. */
+        vendorId: Attribute(2, TlvVendorId),
+        /** Human-readable name of the model for the Node such as the model number assigned by the vendor. */
+        productName: Attribute(3, TlvString32max),
+        /** Product ID assigned by the vendor that is unique to the specific product of the Node. */
+        productId: Attribute(4, TlvUInt16),
+        /** User defined name for the Node. It is set during initial commissioning and may be updated by further reconfigurations. */
+        nodeLabel: WritableAttribute(5, TlvString32max, { default: "", writeAcl: 1 /* AccessLevel.Manage */ }),
+        /** ISO 3166-1 alpha-2 code where the Node is located. Might affect some regulatory aspects. */
+        location: WritableAttribute(6, TlvString.bound({ length: 2 }), { default: "XX", writeAcl: 2 /* AccessLevel.Administer */ }),
+        /** Version number of the hardware of the Node. The meaning of its value, and the versioning scheme, are vendor defined. */
+        hardwareVersion: Attribute(7, TlvUInt16, { default: 0 }),
+        /** Human-readable representation of the {@link BasicInformationCluster.attributes.hardwareVersion hardwareVersion} attribute. */
+        hardwareVersionString: Attribute(8, TlvString.bound({ minLength: 1, maxLength: 64 })),
+        /** Current version number for the software running on this Node. A larger value is newer than a lower value. */
+        softwareVersion: Attribute(9, TlvUInt32, { default: 0 }),
+        /** Human-readable representation of the {@link BasicInformationCluster.attributes.softwareVersion softwareVersion} attribute. */
+        softwareVersionString: Attribute(10, TlvString.bound({ minLength: 1, maxLength: 64 })),
+        /** Node manufacturing date formatted with YYYYMMDD. The additional 8 characters might include other vendor related information. */
+        manufacturingDate: OptionalAttribute(11, TlvString.bound({ minLength: 8, maxLength: 16 })),
+        /** Human-readable vendor assigned part number for the Node whose meaning and numbering scheme is vendor defined. */
+        partNumber: OptionalAttribute(12, TlvString32max),
+        /** Link to a product specific web page following the syntax as specified in RFC 3986. */
+        productURL: OptionalAttribute(13, TlvString256max),
+        /** Vendor specific human readable product label. */
+        productLabel: OptionalAttribute(14, TlvString64max),
+        /** Human readable serial number. */
+        serialNumber: OptionalAttribute(15, TlvString32max),
+        /** Allows to disable the ability to configure the Node through an on-Node user interface. */
+        localConfigDisabled: OptionalWritableAttribute(16, TlvBoolean, { default: false, writeAcl: 1 /* AccessLevel.Manage */ }),
+        /** Indicates whether the Node can be reached over the non-native network for bridged devices. */
+        reachable: OptionalAttribute(17, TlvBoolean, { default: true }),
+        /** Unique identifier for the device, which is constructed in a manufacturer specific manner, updated during factory reset. */
+        uniqueId: OptionalAttribute(18, TlvString32max),
+        /** Minimum guaranteed value for some system-wide, not cluster-specific, resource capabilities. */
+        capabilityMinima: Attribute(19, TlvCapabilityMinima, { default: { caseSessionsPerFabric: 3, subscriptionsPerFabric: 3 } }),
+    },
+    /** @see {@link MatterCoreSpecificationV1_0} § 11.1.6.5 */
+    events: {
+        /** First event fired as soon as reasonable after completing a boot or reboot process. */
+        startUp: Event(0, 0 /* EventPriority.Critical */, { softwareVersion: TlvField(0, TlvUInt32) }),
+        /** Last event fired prior to any orderly shutdown sequence on a best-effort basis. */
+        shutDown: OptionalEvent(1, 0 /* EventPriority.Critical */),
+        /** Fired prior to permanently leaving a given Fabric. */
+        leave: OptionalEvent(2, 1 /* EventPriority.Info */, { fabricIndex: TlvField(0, TlvFabricIndex) }),
+        /** Fired when there is a change in the {@link BasicInformationCluster.attributes.reachable reachable} attribute. */
+        reachableChanged: OptionalEvent(3, 1 /* EventPriority.Info */, { reachableNewValue: TlvField(0, TlvBoolean) }),
+    },
+});

package/dist/es/cluster/BindingCluster.js

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Cluster, WritableAttribute } from "./Cluster.js";
+import { TlvClusterId } from "../common/ClusterId.js";
+import { TlvEndpointNumber } from "../common/EndpointNumber.js";
+import { TlvNodeId } from "../common/NodeId.js";
+import { TlvGroupId } from "../common/GroupId.js";
+import { TlvObject, TlvOptionalField } from "../tlv/TlvObject.js";
+import { TlvArray } from "../tlv/TlvArray.js";
+/**
+ * Provides information about endpoint conformance to a release of a device type definition.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.5.5.1
+ */
+const TlvTarget = TlvObject({
+    /**  Contains the remote target node ID. If the Endpoint field is present, this field SHALL be present. */
+    node: TlvOptionalField(1, TlvNodeId),
+    /** Contains the target group ID that represents remote endpoints. If the Endpoint field is present, this field SHALL NOT be present. */
+    group: TlvOptionalField(2, TlvGroupId),
+    /** Contains the remote endpoint that the local endpoint is bound to. If the Group field is present, this field SHALL NOT be present. */
+    endpoint: TlvOptionalField(3, TlvEndpointNumber),
+    /**
+     * Contains the cluster ID (client & server) on the local and target endpoint(s). If this field is present, the
+     * client cluster SHALL also exist on this endpoint (with this Binding cluster). If this field is present, the
+     * target SHALL be this cluster on the target endpoint(s).
+     */
+    cluster: TlvOptionalField(4, TlvClusterId),
+});
+/**
+ * A binding represents a persistent relationship between an endpoint and one or more other local or
+ * remote endpoints. A binding does not require that the relationship exists. It is up to the node
+ * application to set up the relationship.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.6
+ */
+export const BindingCluster = Cluster({
+    id: 0x1e,
+    name: "Binding",
+    revision: 1,
+    /** @see {@link MatterCoreSpecificationV1_0} § 9.6.5 */
+    attributes: {
+        /** List of device types and corresponding revisions declaring endpoint conformance. */
+        binding: WritableAttribute(0, TlvArray(TlvTarget), { default: [] }), /* non-volatile */
+    },
+});