@project-chip/matter.js 0.0.2 → 0.2.0

package/dist/cjs/schema/BitmapSchema.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteArrayBitmapSchema = exports.BitmapSchema = exports.BitFieldEnum = exports.BitField = exports.BitFlag = void 0;
+const ByteArray_1 = require("../util/ByteArray");
+const Schema_1 = require("./Schema");
+const BitRange = (type, offset, length) => ({ type, offset, length });
+const BitFlag = (offset) => BitRange(0 /* BitRangeType.Flag */, offset, 1);
+exports.BitFlag = BitFlag;
+const BitField = (offset, length) => BitRange(1 /* BitRangeType.Number */, offset, length);
+exports.BitField = BitField;
+const BitFieldEnum = (offset, length) => BitRange(2 /* BitRangeType.Enum */, offset, length);
+exports.BitFieldEnum = BitFieldEnum;
+class BitmapSchemaInternal extends Schema_1.Schema {
+    constructor(bitSchemas) {
+        super();
+        this.bitSchemas = bitSchemas;
+        const masks = {};
+        for (const name in this.bitSchemas) {
+            const { offset, length } = this.bitSchemas[name];
+            masks[name] = ((1 << length) - 1) << offset;
+        }
+        this.masks = masks;
+        // TODO: validate that bitSchemas is coherent
+    }
+    encodeInternal(value) {
+        let result = 0;
+        for (const name in this.bitSchemas) {
+            const { type, offset } = this.bitSchemas[name];
+            switch (type) {
+                case 0 /* BitRangeType.Flag */:
+                    if (value[name])
+                        result |= this.masks[name];
+                    break;
+                case 2 /* BitRangeType.Enum */:
+                case 1 /* BitRangeType.Number */:
+                    result |= value[name] << offset;
+            }
+        }
+        return result;
+    }
+    decodeInternal(bitmap) {
+        const result = {};
+        for (const name in this.bitSchemas) {
+            const { type, offset } = this.bitSchemas[name];
+            const mask = this.masks[name];
+            if (type === 0 /* BitRangeType.Flag */) {
+                result[name] = (bitmap & mask) !== 0;
+            }
+            else {
+                result[name] = (bitmap & mask) >> offset;
+            }
+        }
+        return result;
+    }
+}
+class ByteArrayBitmapSchemaInternal extends Schema_1.Schema {
+    constructor(bitSchemas) {
+        super();
+        this.bitSchemas = bitSchemas;
+        let maxBitLength = 0;
+        const maskOffset = {};
+        for (const name in this.bitSchemas) {
+            const { offset, length } = this.bitSchemas[name];
+            const bitOffset = offset % 8;
+            const byteOffset = (offset - bitOffset) / 8;
+            const mask = ((1 << length) - 1) << bitOffset;
+            maskOffset[name] = { bitOffset, byteOffset, mask };
+            maxBitLength = Math.max(maxBitLength, offset + length);
+        }
+        this.byteArrayLength = Math.ceil(maxBitLength / 8);
+        this.maskOffset = maskOffset;
+    }
+    encodeInternal(value) {
+        let result = new ByteArray_1.ByteArray(this.byteArrayLength);
+        for (const name in this.bitSchemas) {
+            const { type } = this.bitSchemas[name];
+            let { mask, bitOffset, byteOffset } = this.maskOffset[name];
+            switch (type) {
+                case 0 /* BitRangeType.Flag */:
+                    if (value[name])
+                        result[byteOffset] |= mask;
+                    break;
+                case 2 /* BitRangeType.Enum */:
+                case 1 /* BitRangeType.Number */:
+                    let numValue = value[name];
+                    while (mask !== 0) {
+                        result[byteOffset++] |= ((numValue & mask) << bitOffset) & 0xFF;
+                        const bitWritten = 8 - bitOffset;
+                        bitOffset = 0;
+                        numValue = numValue >> bitWritten;
+                        mask = mask >> 8;
+                    }
+            }
+        }
+        return result;
+    }
+    decodeInternal(bitmap) {
+        if (bitmap.length !== this.byteArrayLength)
+            throw new Error(`Unexpected length: ${bitmap.length}. Expected ${this.byteArrayLength}`);
+        const result = {};
+        for (const name in this.bitSchemas) {
+            const { type } = this.bitSchemas[name];
+            let { mask, bitOffset, byteOffset } = this.maskOffset[name];
+            if (type === 0 /* BitRangeType.Flag */) {
+                result[name] = (bitmap[byteOffset] & mask) !== 0;
+            }
+            else {
+                let value = 0;
+                let valueBitOffset = 0;
+                while (mask !== 0) {
+                    value |= ((bitmap[byteOffset++] & mask) >> bitOffset) << valueBitOffset;
+                    const bitWritten = 8 - bitOffset;
+                    bitOffset = 0;
+                    valueBitOffset += bitWritten;
+                    mask = mask >> 8;
+                }
+                result[name] = value;
+            }
+        }
+        return result;
+    }
+}
+/** Declares a bitmap schema by indicating the bit position and their names. */
+const BitmapSchema = (bitSchemas) => new BitmapSchemaInternal(bitSchemas);
+exports.BitmapSchema = BitmapSchema;
+/** Declares a bitmap schema backed by a ByteArray by indicating the bit position and their names. */
+const ByteArrayBitmapSchema = (bitSchemas) => new ByteArrayBitmapSchemaInternal(bitSchemas);
+exports.ByteArrayBitmapSchema = ByteArrayBitmapSchema;

package/{dist-cjs → dist/cjs}/tlv/TlvObject.js

@@ -7,6 +7,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TlvOptionalField = exports.TlvField = exports.TlvList = exports.TlvObject = exports.ObjectSchema = void 0;
 const TlvSchema_js_1 = require("./TlvSchema.js");
+const TlvAny_js_1 = require("./TlvAny.js");
 ;
 /**
  * Schema to encode an object in TLV.
@@ -51,8 +52,11 @@ class ObjectSchema extends TlvSchema_js_1.TlvSchema {
             if (id === undefined)
                 throw new Error("Structure element tags should have an id.");
             const fieldName = this.fieldById[id];
-            if (fieldName === undefined)
-                throw new Error(`Unknown field ${id}`);
+            if (fieldName === undefined) {
+                // Ignore unknown field by decoding it as raw TLV so we skip forward the proper length.
+                TlvAny_js_1.TlvAny.decodeTlvInternalValue(reader, elementTypeLength);
+                continue;
+            }
             const { field, name } = fieldName;
             result[name] = field.schema.decodeTlvInternalValue(reader, elementTypeLength);
         }

package/{dist-cjs → dist/cjs}/util/ByteArray.js

@@ -19,6 +19,8 @@ Uint8Array.prototype.equals = function (other) {
 };
 Uint8Array.fromHex = function (hexString) {
     var _a;
+    if (hexString.length === 0)
+        return new exports.ByteArray(0);
     if (hexString.length % 2 !== 0)
         throw new Error("Hex string should have an even length.");
     const bytes = (_a = hexString.match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map(byteHex => parseInt(byteHex, 16));

package/{dist-cjs → dist/cjs}/util/Type.js

@@ -5,3 +5,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Merge = void 0;
+const Merge = (a, b) => (Object.assign(Object.assign({}, a), b));
+exports.Merge = Merge;

package/dist/dts/cluster/AccessControlCluster.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Cluster, WritableAttribute, Attribute, Event } from "./Cluster.js";
+/**
+ * List of privileges that can be granted to a subject.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.10.5.3
+ */
+export declare const enum Privilege {
+    /** Can read and observe all (except Access Control Cluster and as seen by a non-Proxy). */
+    View = 1,
+    /** An read and observe all (as seen by a Proxy). */
+    ProxyView = 2,
+    /** View privileges, and can perform the primary function of this Node (except Access Control Cluster). */
+    Operate = 3,
+    /** Operate privileges, and can modify persistent configuration of this Node (except Access Control Cluster). */
+    Manage = 4,
+    /** Manage privileges, and can observe and modify the Access Control Cluster. */
+    Administer = 5
+}
+/**
+ * List of Auth Modes that can be used to authenticate a subject.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.10.5.3
+ */
+export declare const enum AuthMode {
+    /** Passcode authenticated session. */
+    PASE = 1,
+    /** Certificate authenticated session. */
+    CASE = 2,
+    /** Group authenticated session. */
+    Group = 3
+}
+/** @see {@link MatterCoreSpecificationV1_0} § 9.10.8.1 */
+export declare const enum ChangeTypeEnum {
+    /** Entry or extension was changed. */
+    Changed = 0,
+    /** Entry or extension was added. */
+    Added = 1,
+    /** Entry or extension was removed. */
+    Removed = 2
+}
+/**
+ * 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 declare const AccessControlCluster: Cluster<import("../matter.js").BitSchema, {
+    acl: WritableAttribute<{
+        privilege: Privilege;
+        authMode: AuthMode;
+        subjects: import("../common/NodeId.js").NodeId[] | null;
+        targets: {
+            cluster: import("../common/ClusterId.js").ClusterId | null;
+            endpoint: import("../common/EndpointNumber.js").EndpointNumber | null;
+            deviceType: import("../common/DeviceTypeId.js").DeviceTypeId | null;
+        }[] | null;
+    }[]>;
+    extension: WritableAttribute<{
+        data: Uint8Array;
+    }[]>;
+    subjectsPerAccessControlEntry: Attribute<number>;
+    targetsPerAccessControlEntry: Attribute<number>;
+    accessControlEntriesPerFabric: Attribute<number>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+}, import("./Cluster.js").Commands, {
+    /**
+     * The cluster SHALL send AccessControlEntryChanged events whenever its ACL attribute data is changed by an
+     * Administrator.
+     */
+    accessControlEntryChanged: Event<{
+        adminNodeID: import("../common/NodeId.js").NodeId | null;
+        adminPasscodeID: number | null;
+        changeType: ChangeTypeEnum;
+        latestValue: {
+            privilege: Privilege;
+            authMode: AuthMode;
+            subjects: import("../common/NodeId.js").NodeId[] | null;
+            targets: {
+                cluster: import("../common/ClusterId.js").ClusterId | null;
+                endpoint: import("../common/EndpointNumber.js").EndpointNumber | null;
+                deviceType: import("../common/DeviceTypeId.js").DeviceTypeId | null;
+            }[] | null;
+        } | null;
+    }>;
+    /**
+     * The cluster SHALL send AccessControlExtensionChanged events whenever its extension attribute data is changed
+     * by an Administrator.
+     */
+    accessControlExtensionChanged: Event<{
+        adminNodeID: import("../common/NodeId.js").NodeId | null;
+        adminPasscodeID: number | null;
+        changeType: ChangeTypeEnum;
+        latestValue: {
+            data: Uint8Array;
+        } | null;
+    }>;
+}>;

package/dist/dts/cluster/BasicInformationCluster.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, Cluster, Event, OptionalAttribute, WritableAttribute } from "./Cluster.js";
+/**
+ * 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 declare const BasicInformationCluster: Cluster<import("../matter.js").BitSchema, {
+    dataModelRevision: Attribute<number>;
+    vendorName: Attribute<string>;
+    vendorId: Attribute<import("../common/VendorId.js").VendorId>;
+    productName: Attribute<string>;
+    productId: Attribute<number>;
+    nodeLabel: WritableAttribute<string>;
+    location: WritableAttribute<string>;
+    hardwareVersion: Attribute<number>;
+    hardwareVersionString: Attribute<string>;
+    softwareVersion: Attribute<number>;
+    softwareVersionString: Attribute<string>;
+    manufacturingDate: OptionalAttribute<string>;
+    partNumber: OptionalAttribute<string>;
+    productURL: OptionalAttribute<string>;
+    productLabel: OptionalAttribute<string>;
+    serialNumber: OptionalAttribute<string>;
+    localConfigDisabled: WritableAttribute<boolean>;
+    reachable: OptionalAttribute<boolean>;
+    uniqueId: OptionalAttribute<string>;
+    capabilityMinima: Attribute<{
+        caseSessionsPerFabric: number;
+        subscriptionsPerFabric: number;
+    }>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+}, import("./Cluster.js").Commands, {
+    /** First event fired as soon as reasonable after completing a boot or reboot process. */
+    startUp: Event<{
+        softwareVersion: number;
+    }>;
+    /** Last event fired prior to any orderly shutdown sequence on a best-effort basis. */
+    shutDown: Event<{
+        [x: string]: any;
+    }>;
+    /** Fired prior to permanently leaving a given Fabric. */
+    leave: Event<{
+        fabricIndex: import("../common/FabricIndex.js").FabricIndex;
+    }>;
+    /** Fired when there is a change in the {@link BasicInformationCluster.attributes.reachable reachable} attribute. */
+    reachableChanged: Event<{
+        reachableNewValue: boolean;
+    }>;
+}>;

package/dist/dts/cluster/BindingCluster.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Cluster, WritableAttribute } from "./Cluster.js";
+/**
+ * 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 declare const BindingCluster: Cluster<import("../matter.js").BitSchema, {
+    binding: WritableAttribute<{
+        group?: import("../common/GroupId.js").GroupId | undefined;
+        cluster?: import("../common/ClusterId.js").ClusterId | undefined;
+        endpoint?: import("../common/EndpointNumber.js").EndpointNumber | undefined;
+        node?: import("../common/NodeId.js").NodeId | undefined;
+    }[]>;
+    clusterRevision: import("./Cluster.js").Attribute<number>;
+    featureMap: import("./Cluster.js").Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+}, import("./Cluster.js").Commands, import("./Cluster.js").Events>;

package/dist/dts/cluster/BridgedDeviceBasicInformationCluster.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, Cluster, Event, OptionalAttribute } from "./Cluster.js";
+/**
+ * This Cluster serves two purposes towards a Node communicating with a Bridge:
+ * * indicate that the functionality on the Endpoint where it is placed (and its Parts) is bridged from a
+ *   non-Matter technology, and
+ * * provide a centralized collection of attributes that the Node MAY collect to aid in conveying information
+ *   regarding the Bridged Device to a user, such as the vendor name, the model name, or user-assigned name.
+ *
+ * This cluster is Derived from Basic Information Cluster.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.13
+ */
+export declare const BridgedDeviceBasicInformationCluster: Cluster<import("../matter.js").BitSchema, {
+    vendorName: OptionalAttribute<string>;
+    vendorId: OptionalAttribute<import("../common/VendorId.js").VendorId>;
+    productName: OptionalAttribute<string>;
+    nodeLabel: import("./Cluster.js").WritableAttribute<string>;
+    hardwareVersion: OptionalAttribute<number>;
+    hardwareVersionString: OptionalAttribute<string>;
+    softwareVersion: OptionalAttribute<number>;
+    softwareVersionString: OptionalAttribute<string>;
+    manufacturingDate: OptionalAttribute<string>;
+    partNumber: OptionalAttribute<string>;
+    productURL: OptionalAttribute<string>;
+    productLabel: OptionalAttribute<string>;
+    serialNumber: OptionalAttribute<string>;
+    reachable: Attribute<boolean>;
+    uniqueId: OptionalAttribute<string>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+}, import("./Cluster.js").Commands, {
+    /** First event fired as soon as reasonable after completing a boot or reboot process. */
+    startUp: Event<{
+        softwareVersion: number;
+    }>;
+    /** Last event fired prior to any orderly shutdown sequence on a best-effort basis. */
+    shutDown: Event<{
+        [x: string]: any;
+    }>;
+    /** Fired prior to permanently leaving a given Fabric. */
+    leave: Event<{
+        fabricIndex: import("../common/FabricIndex.js").FabricIndex;
+    }>;
+    /** Fired when there is a change in the {@link BasicInformationCluster.attributes.reachable reachable} attribute */
+    reachableChanged: Event<{
+        reachableNewValue: boolean;
+    }>;
+}>;

package/dist/dts/cluster/Cluster.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BitSchema, TypeFromBitSchema } from "../schema/BitmapSchema.js";
+import { TlvFields, TypeFromFields } from "../tlv/TlvObject.js";
+import { TlvSchema } from "../tlv/TlvSchema.js";
+import { Merge } from "../util/Type.js";
+export declare const enum AccessLevel {
+    View = 0,
+    Manage = 1,
+    Administer = 2
+}
+export interface Attribute<T> {
+    id: number;
+    schema: TlvSchema<T>;
+    optional: boolean;
+    readAcl: AccessLevel;
+    writable: boolean;
+    writeAcl?: AccessLevel;
+    default?: T;
+}
+export interface OptionalAttribute<T> extends Attribute<T> {
+    optional: true;
+}
+export interface WritableAttribute<T> extends Attribute<T> {
+    writable: true;
+}
+export interface OptionalWritableAttribute<T> extends OptionalAttribute<T> {
+    writable: true;
+}
+export type AttributeJsType<T extends Attribute<any>> = T extends Attribute<infer JsType> ? JsType : never;
+interface AttributeOptions<T> {
+    default?: T;
+    readAcl?: AccessLevel;
+    writeAcl?: AccessLevel;
+}
+export declare const Attribute: <T, V extends T>(id: number, schema: TlvSchema<T>, { default: conformanceValue, readAcl }?: AttributeOptions<V>) => Attribute<T>;
+export declare const OptionalAttribute: <T, V extends T>(id: number, schema: TlvSchema<T>, { default: conformanceValue, readAcl }?: AttributeOptions<V>) => OptionalAttribute<T>;
+export declare const WritableAttribute: <T, V extends T>(id: number, schema: TlvSchema<T>, { default: conformanceValue, readAcl, writeAcl }?: AttributeOptions<V>) => WritableAttribute<T>;
+export declare const OptionalWritableAttribute: <T, V extends T>(id: number, schema: TlvSchema<T>, { default: conformanceValue, readAcl, writeAcl }?: AttributeOptions<V>) => WritableAttribute<T>;
+export declare const TlvNoArguments: import("../tlv/TlvObject.js").ObjectSchema<{}>;
+export declare const TlvNoResponse: import("../tlv/TlvVoid.js").VoidSchema;
+export interface Command<RequestT, ResponseT> {
+    optional: boolean;
+    requestId: number;
+    requestSchema: TlvSchema<RequestT>;
+    responseId: number;
+    responseSchema: TlvSchema<ResponseT>;
+}
+export interface OptionalCommand<RequestT, ResponseT> extends Command<RequestT, ResponseT> {
+    optional: true;
+}
+export type ResponseType<T extends Command<any, any>> = T extends OptionalCommand<any, infer ResponseT> ? ResponseT | undefined : (T extends Command<any, infer ResponseT> ? ResponseT : never);
+export type RequestType<T extends Command<any, any>> = T extends Command<infer RequestT, any> ? RequestT : never;
+export declare const Command: <RequestT, ResponseT>(requestId: number, requestSchema: TlvSchema<RequestT>, responseId: number, responseSchema: TlvSchema<ResponseT>) => Command<RequestT, ResponseT>;
+export declare const OptionalCommand: <RequestT, ResponseT>(requestId: number, requestSchema: TlvSchema<RequestT>, responseId: number, responseSchema: TlvSchema<ResponseT>) => OptionalCommand<RequestT, ResponseT>;
+export declare const enum EventPriority {
+    Critical = 0,
+    Info = 1
+}
+export interface Event<T> {
+    id: number;
+    schema: TlvSchema<T>;
+    priority: EventPriority;
+    optional: boolean;
+}
+export interface OptionalEvent<T> extends Event<T> {
+    optional: true;
+}
+export declare const Event: <FT extends TlvFields>(id: number, priority: EventPriority, data?: FT) => Event<Merge<{ [K_1 in { [K in keyof FT]: FT[K] extends import("../tlv/TlvObject.js").OptionalFieldType<any> ? never : K; }[keyof FT]]: FT[K_1] extends infer T ? T extends FT[K_1] ? T extends import("../tlv/TlvObject.js").FieldType<infer T_1> ? T_1 : never : never : never; }, { [K_3 in { [K_2 in keyof FT]: FT[K_2] extends import("../tlv/TlvObject.js").OptionalFieldType<any> ? K_2 : never; }[keyof FT]]?: (FT[K_3] extends infer T_2 ? T_2 extends FT[K_3] ? T_2 extends import("../tlv/TlvObject.js").FieldType<infer T_1> ? T_1 : never : never : never) | undefined; }>>;
+export declare const OptionalEvent: <FT extends TlvFields>(id: number, priority: EventPriority, data?: FT) => Event<Merge<{ [K_1 in { [K in keyof FT]: FT[K] extends import("../tlv/TlvObject.js").OptionalFieldType<any> ? never : K; }[keyof FT]]: FT[K_1] extends infer T ? T extends FT[K_1] ? T extends import("../tlv/TlvObject.js").FieldType<infer T_1> ? T_1 : never : never : never; }, { [K_3 in { [K_2 in keyof FT]: FT[K_2] extends import("../tlv/TlvObject.js").OptionalFieldType<any> ? K_2 : never; }[keyof FT]]?: (FT[K_3] extends infer T_2 ? T_2 extends FT[K_3] ? T_2 extends import("../tlv/TlvObject.js").FieldType<infer T_1> ? T_1 : never : never : never) | undefined; }>>;
+export interface Attributes {
+    [key: string]: Attribute<any>;
+}
+export interface Commands {
+    [key: string]: Command<any, any>;
+}
+export interface Events {
+    [key: string]: Event<any>;
+}
+/** @see {@link MatterCoreSpecificationV1_0} § 7.13 */
+export type GlobalAttributes<F extends BitSchema> = {
+    /** Indicates the revision of the server cluster specification supported by the cluster instance. */
+    clusterRevision: Attribute<number>;
+    /** Indicates whether the server supports zero or more optional clus­ter features. */
+    featureMap: Attribute<TypeFromBitSchema<F>>;
+};
+export declare const GlobalAttributes: <F extends BitSchema>(features: F) => GlobalAttributes<F>;
+export interface Cluster<F extends BitSchema, A extends Attributes, C extends Commands, E extends Events> {
+    id: number;
+    name: string;
+    revision: number;
+    features: BitSchema;
+    attributes: A;
+    commands: C;
+    events: E;
+}
+export declare const Cluster: <F extends BitSchema, A extends Attributes, C extends Commands, E extends Events>({ id, name, revision, features, attributes, commands, events, }: {
+    id: number;
+    name: string;
+    revision: number;
+    features?: F | undefined;
+    attributes?: A | undefined;
+    commands?: C | undefined;
+    events?: E | undefined;
+}) => Cluster<F, Merge<A, GlobalAttributes<F>>, C, E>;
+export {};

package/dist/dts/cluster/DescriptorCluster.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, Cluster } from "./Cluster.js";
+/**
+ * This cluster describes an endpoint instance on the node, independently of other endpoints, but also
+ * allows composition of endpoints to conform to complex device type patterns.
+ * This Cluster is also meant to replace the support from the Zigbee Device Object (ZDO) for describing a node,
+ * its endpoints and clusters.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.5
+ */
+export declare const DescriptorCluster: Cluster<import("../matter.js").BitSchema, {
+    deviceTypeList: Attribute<{
+        type: import("../common/DeviceTypeId.js").DeviceTypeId;
+        revision: number;
+    }[]>;
+    serverList: Attribute<import("../common/ClusterId.js").ClusterId[]>;
+    clientList: Attribute<import("../common/ClusterId.js").ClusterId[]>;
+    partsList: Attribute<import("../common/EndpointNumber.js").EndpointNumber[]>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+}, import("./Cluster.js").Commands, import("./Cluster.js").Events>;

package/dist/dts/cluster/GeneralCommissioningCluster.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, Cluster, Command, WritableAttribute } from "./Cluster.js";
+import { TypeFromSchema } from "../tlv/TlvSchema.js";
+/**
+ * This enumeration is used by the RegulatoryConfig and LocationCapability attributes to indicate possible radio usage.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 11.9.5.3
+ */
+export declare const enum RegulatoryLocationType {
+    /** Indoor only */
+    Indoor = 0,
+    /** Outdoor only */
+    Outdoor = 1,
+    /** Indoor/Outdoor */
+    IndoorOutdoor = 2
+}
+/**
+ * This enumeration is used by several response commands in this cluster to indicate particular errors.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 11.9.5.1
+ */
+export declare const enum CommissioningError {
+    /** No error. */
+    Ok = 0,
+    /** Attempting to set regulatory configuration to a region or indoor/outdoor mode for which the server does not have proper configuration. */
+    ValueOutsideRange = 1,
+    /** Executed CommissioningComplete outside CASE session. */
+    InvalidAuthentication = 2,
+    /** Executed CommissioningComplete when there was no active Fail-Safe context. */
+    NoFailSafe = 3,
+    /** Attempting to arm fail-safe or execute CommissioningComplete from a fabric different than the one associated with the current fail-safe context. */
+    BusyWithOtherAdmin = 4
+}
+/**
+ * Used by the following commands as response payload:
+ * ArmFailSafeResponse, @see {@link MatterCoreSpecificationV1_0} § 11.9.7.3
+ * CommissioningCompleteResponse, @see {@link MatterCoreSpecificationV1_0} § 11.9.7.7
+ * CommissioningCompleteResponse, @see {@link MatterCoreSpecificationV1_0} § 11.9.7.7
+ */
+declare const TlvCommissioningSuccessFailureResponse: import("../tlv/TlvObject.js").ObjectSchema<{
+    /** Contain the result of the operation. */
+    errorCode: import("../tlv/TlvObject.js").FieldType<CommissioningError>;
+    /** Should help developers in troubleshooting errors. The value MAY go into logs or crash reports, not User UIs. */
+    debugText: import("../tlv/TlvObject.js").FieldType<string>;
+}>;
+export type CommissioningSuccessFailureResponse = TypeFromSchema<typeof TlvCommissioningSuccessFailureResponse>;
+/**
+ * This cluster is used to manage global aspects of the Commissioning flow.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 11.9
+ */
+export declare const GeneralCommissioningCluster: Cluster<import("../matter.js").BitSchema, {
+    breadcrumb: WritableAttribute<number | bigint>;
+    commissioningInfo: Attribute<{
+        failSafeExpiryLengthSeconds: number;
+        maxCumulativeFailsafeSeconds: number;
+    }>;
+    regulatoryConfig: Attribute<RegulatoryLocationType>;
+    locationCapability: Attribute<RegulatoryLocationType>;
+    supportsConcurrentConnections: Attribute<boolean>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+}, {
+    /** Arms the persistent fail-safe timer with an expiry time of now + ExpiryLengthSeconds using device clock. */
+    armFailSafe: Command<{
+        expiryLengthSeconds: number;
+        breadcrumbStep: number | bigint;
+    }, {
+        errorCode: CommissioningError;
+        debugText: string;
+    }>;
+    /** Sets or Updates the regulatory configuration to be used during commissioning. */
+    setRegulatoryConfig: Command<{
+        breadcrumbStep: number | bigint;
+        newRegulatoryConfig: RegulatoryLocationType;
+        countryCode: string;
+    }, {
+        errorCode: CommissioningError;
+        debugText: string;
+    }>;
+    /**
+     * Informs that all steps of Commissioning/Reconfiguration needed during the fail-safe period have been
+     * completed.
+     */
+    commissioningComplete: Command<{}, {
+        errorCode: CommissioningError;
+        debugText: string;
+    }>;
+}, import("./Cluster.js").Events>;
+export {};