@project-chip/matter.js 0.0.1 → 0.1.0

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 {};

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

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, Cluster, Command } from "./Cluster.js";
+import { BitFlag } from "../schema/BitmapSchema.js";
+import { StatusCode } from "../protocol/InteractionProtocol.js";
+/**
+ * The Groups cluster manages, per endpoint, the content of the node-wide Group
+ * Table that is part of the underlying interaction layer.
+ *
+ * @see {@link MatterApplicationClusterSpecificationV1_0} § 1.3
+ */
+export declare const GroupsCluster: Cluster<{
+    /** The ability to store a name for a group. */
+    groupNames: BitFlag;
+}, {
+    nameSupport: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<{
+        groupNames: BitFlag;
+    }>>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<{
+        /** The ability to store a name for a group. */
+        groupNames: BitFlag;
+    }>>;
+}, {
+    /**
+     * The AddGroup command allows a client to add group membership in a particular group for the server endpoint.
+     */
+    addGroup: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+        groupName: string;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+    }>;
+    /**
+     * The ViewGroup command allows a client to request that the server responds with a ViewGroupResponse command
+     * containing the name string for a particular group.
+     *
+     */
+    viewGroup: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+        groupName: string;
+    }>;
+    /**
+     * The GetGroupMembership command allows a client to inquire about the group membership of the server endpoint,
+     * in a number of ways.
+     */
+    getGroupMembership: Command<{
+        groupList: import("../common/GroupId.js").GroupId[];
+    }, {
+        groupList: import("../common/GroupId.js").GroupId[];
+        capacity: number | null;
+    }>;
+    /**
+     * The RemoveGroup command allows a client to request that the server removes the membership for the server
+     * endpoint, if any, in a particular group.
+     */
+    removeGroup: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+    }>;
+    /**
+     * The RemoveAllGroups command allows a client to direct the server to remove all group associations for the
+     * server endpoint.
+     *
+     * TODO: According to specs the response might be suppressed:
+     * If the RemoveAllGroups command was received as unicast and a response is not suppressed, the server
+     * SHALL generate a response with the Status field set to SUCCESS.
+     * Else potentially no response?
+     *
+     */
+    removeAllGroups: Command<{}, {
+        status: StatusCode;
+    }>;
+    /**
+     * The AddGroupIfIdentifying command allows a client to add group membership in a particular group for the
+     * server endpoint, on condition that the endpoint is identifying itself.
+     *
+     */
+    addGroupIfIdentifying: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+        groupName: string;
+    }, void>;
+}, import("./Cluster.js").Events>;

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

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, WritableAttribute, Cluster, Command, OptionalCommand } from "./Cluster.js";
+import { BitFlag } from "../schema/BitmapSchema.js";
+/** @see {@link MatterApplicationClusterSpecificationV1_0} § 1.2.5.2 */
+export declare const enum IdentifyType {
+    None = 0,
+    VisibleLight = 1,
+    VisibleLED = 2,
+    AudibleBeep = 3,
+    Display = 4,
+    Actuator = 5
+}
+/** @see {@link MatterApplicationClusterSpecificationV1_0} § 1.2.6.3.1 */
+export declare const enum IdentifyEffectIdentifier {
+    Blink = 0,
+    Breathe = 1,
+    Okay = 2,
+    ChannelChange = 11,
+    FinishEffect = 254,
+    StopEffect = 255
+}
+/** @see {@link MatterApplicationClusterSpecificationV1_0} § 1.2.6.3.2 */
+export declare const enum EffectVariant {
+    Default = 0
+}
+/**
+ * Attributes and commands for putting a device into Identification mode (e.g. flashing a light).
+ *
+ * @see {@link MatterApplicationClusterSpecificationV1_0} § 1.2
+ */
+export declare const IdentifyCluster: Cluster<{
+    /** Replies to multicast / groupcast queries if the identification state is active. */
+    query: BitFlag;
+}, {
+    identifyTime: WritableAttribute<number>;
+    identifyType: Attribute<IdentifyType>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<{
+        /** Replies to multicast / groupcast queries if the identification state is active. */
+        query: BitFlag;
+    }>>;
+}, {
+    /** Starts or stops the receiving device identifying itself. */
+    identify: Command<{
+        identifyTime: number;
+    }, void>;
+    /** Request the target or targets to respond if they are currently identifying themselves. */
+    identifyQuery: Command<{}, {
+        timeout: number;
+    }>;
+    /** Allows the support of feedback to the user, such as a certain light effect when identifying. */
+    triggerEffect: OptionalCommand<{
+        effectIdentifier: IdentifyEffectIdentifier;
+        effectVariant: EffectVariant;
+    }, void>;
+}, import("./Cluster.js").Events>;

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

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, Cluster, WritableAttribute } from "./Cluster.js";
+/**
+ * This cluster provides a feature to tag an endpoint with zero or more labels.
+ * Derived from LabelCluster ({@link MatterCoreSpecificationV1_0} § 9.7)
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.9
+ */
+export declare const UserLabelCluster: Cluster<import("../matter.js").BitSchema, {
+    labelList: WritableAttribute<{
+        value: string;
+        label: string;
+    }[]>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+}, import("./Cluster.js").Commands, import("./Cluster.js").Events>;
+/**
+ * This cluster provides a feature for the device to tag an endpoint with zero or more read only labels.
+ * Derived from LabelCluster ({@link MatterCoreSpecificationV1_0} § 9.7)
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 9.8
+ */
+export declare const FixedLabelCluster: Cluster<import("../matter.js").BitSchema, {
+    labelList: Attribute<{
+        value: string;
+        label: string;
+    }[]>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+}, import("./Cluster.js").Commands, import("./Cluster.js").Events>;