@project-chip/matter.js 0.2.0 → 0.3.0

package/dist/es/cluster/ClusterHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClusterHelper.d.ts","sourceRoot":"","sources":["../../../src/cluster/ClusterHelper.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA6BlD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B1B,CAAC;AAEF,UAAU,mBAAmB;IACzB,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;CAChB;AAGD,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAE7E;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAoBrI"}

package/dist/es/cluster/ClusterHelper.js

@@ -0,0 +1,81 @@
+import { AccessControlCluster } from "./AccessControlCluster.js";
+import { ActionsCluster } from "./ActionsCluster.js";
+import { AdminCommissioningCluster } from "./AdminCommissioningCluster.js";
+import { BasicInformationCluster } from "./BasicInformationCluster.js";
+import { BindingCluster } from "./BindingCluster.js";
+import { BooleanStateCluster } from "./BooleanStateCluster.js";
+import { BridgedDeviceBasicInformationCluster } from "./BridgedDeviceBasicInformationCluster.js";
+import { DescriptorCluster } from "./DescriptorCluster.js";
+import { FlowMeasurementCluster } from "./FlowMeasurementCluster.js";
+import { GeneralCommissioningCluster } from "./GeneralCommissioningCluster.js";
+import { GroupsCluster } from "./GroupsCluster.js";
+import { IdentifyCluster } from "./IdentifyCluster.js";
+import { IlluminanceMeasurementCluster } from "./IlluminanceMeasurementCluster.js";
+import { UserLabelCluster, FixedLabelCluster } from "./LabelCluster.js";
+import { LevelControlCluster } from "./LevelControlCluster.js";
+import { NetworkCommissioningCluster } from "./NetworkCommissioningCluster.js";
+import { OccupancySensingCluster } from "./OccupancySensingCluster.js";
+import { OnOffCluster } from "./OnOffCluster.js";
+import { OperationalCredentialsCluster } from "./OperationalCredentialsCluster.js";
+import { PowerSourceCluster } from "./PowerSourceCluster.js";
+import { PowerSourceConfigurationCluster } from "./PowerSourceConfigurationCluster.js";
+import { PressureMeasurementCluster } from "./PressureMeasurementCluster.js";
+import { ScenesCluster } from "./ScenesCluster.js";
+import { TemperatureMeasurementCluster } from "./TemperatureMeasurementCluster.js";
+import { RelativeHumidityCluster, SoilMoistureMeasurementCluster, LeafWetnessMeasurementCluster } from "./WaterContentMeasurementCluster.js";
+import { GeneralDiagnosticsCluster } from "./GeneralDiagnosticsCluster.js";
+import { GroupKeyManagementCluster } from "./GroupKeyManagementCluster.js";
+export const AllClustersMap = {
+    [AccessControlCluster.id]: AccessControlCluster,
+    [ActionsCluster.id]: ActionsCluster,
+    [AdminCommissioningCluster.id]: AdminCommissioningCluster,
+    [BasicInformationCluster.id]: BasicInformationCluster,
+    [BindingCluster.id]: BindingCluster,
+    [BooleanStateCluster.id]: BooleanStateCluster,
+    [BridgedDeviceBasicInformationCluster.id]: BridgedDeviceBasicInformationCluster,
+    [DescriptorCluster.id]: DescriptorCluster,
+    [FlowMeasurementCluster.id]: FlowMeasurementCluster,
+    [GeneralCommissioningCluster.id]: GeneralCommissioningCluster,
+    [GeneralDiagnosticsCluster.id]: GeneralDiagnosticsCluster,
+    [GroupKeyManagementCluster.id]: GroupKeyManagementCluster,
+    [GroupsCluster.id]: GroupsCluster,
+    [IdentifyCluster.id]: IdentifyCluster,
+    [IlluminanceMeasurementCluster.id]: IlluminanceMeasurementCluster,
+    [UserLabelCluster.id]: UserLabelCluster,
+    [FixedLabelCluster.id]: FixedLabelCluster,
+    [LevelControlCluster.id]: LevelControlCluster,
+    [NetworkCommissioningCluster.id]: NetworkCommissioningCluster,
+    [OccupancySensingCluster.id]: OccupancySensingCluster,
+    [OnOffCluster.id]: OnOffCluster,
+    [OperationalCredentialsCluster.id]: OperationalCredentialsCluster,
+    [PowerSourceCluster.id]: PowerSourceCluster,
+    [PowerSourceConfigurationCluster.id]: PowerSourceConfigurationCluster,
+    [PressureMeasurementCluster.id]: PressureMeasurementCluster,
+    [ScenesCluster.id]: ScenesCluster,
+    [TemperatureMeasurementCluster.id]: TemperatureMeasurementCluster,
+    [RelativeHumidityCluster.id]: RelativeHumidityCluster,
+    [LeafWetnessMeasurementCluster.id]: LeafWetnessMeasurementCluster,
+    [SoilMoistureMeasurementCluster.id]: SoilMoistureMeasurementCluster,
+};
+const clusterAttributeCache = new Map();
+export function getClusterById(clusterId) {
+    return AllClustersMap[clusterId];
+}
+export function getClusterAttributeById(clusterDef, attributeId) {
+    if (!clusterAttributeCache.has(clusterDef.id)) {
+        const attributeMap = new Map();
+        const { attributes } = clusterDef;
+        // Add accessors
+        for (const attributeName in attributes) {
+            const attribute = attributes[attributeName];
+            attributeMap.set(attribute.id, { attribute, name: attributeName });
+        }
+        clusterAttributeCache.set(clusterDef.id, attributeMap);
+        return attributeMap.get(attributeId);
+    }
+    const attributeMap = clusterAttributeCache.get(clusterDef.id);
+    if (attributeMap === undefined) {
+        return undefined;
+    }
+    return attributeMap.get(attributeId);
+}

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

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2022-2023 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("../schema/BitmapSchema.js").BitSchema, {
+    deviceTypeList: Attribute<{
+        revision: number;
+        deviceType: import("../datatype/DeviceTypeId.js").DeviceTypeId;
+    }[]>;
+    serverList: Attribute<import("../datatype/ClusterId.js").ClusterId[]>;
+    clientList: Attribute<import("../datatype/ClusterId.js").ClusterId[]>;
+    partsList: Attribute<import("../datatype/EndpointNumber.js").EndpointNumber[]>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<import("../schema/BitmapSchema.js").BitSchema>>;
+    attributeList: Attribute<import("../datatype/AttributeId.js").AttributeId[]>;
+    eventList: Attribute<import("../datatype/EventId.js").EventId[]>;
+    acceptedCommandList: Attribute<import("../datatype/CommandId.js").CommandId[]>;
+    generatedCommandList: Attribute<import("../datatype/CommandId.js").CommandId[]>;
+}, import("./Cluster.js").Commands, import("./Cluster.js").Events>;
+//# sourceMappingURL=DescriptorCluster.d.ts.map

package/dist/es/cluster/DescriptorCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DescriptorCluster.d.ts","sourceRoot":"","sources":["../../../src/cluster/DescriptorCluster.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAsBlD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;kEAsB5B,CAAC"}

package/dist/es/cluster/DescriptorCluster.js

@@ -1,15 +1,15 @@
 /**
  * @license
- * Copyright 2022 Project CHIP Authors
+ * Copyright 2022-2023 Project CHIP Authors
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Attribute, Cluster } from "./Cluster.js";
-import { TlvDeviceTypeId } from "../common/DeviceTypeId.js";
-import { TlvClusterId } from "../common/ClusterId.js";
-import { TlvEndpointNumber } from "../common/EndpointNumber.js";
 import { TlvField, TlvObject } from "../tlv/TlvObject.js";
+import { TlvDeviceTypeId } from "../datatype/DeviceTypeId.js";
 import { TlvUInt16 } from "../tlv/TlvNumber.js";
 import { TlvArray } from "../tlv/TlvArray.js";
+import { TlvClusterId } from "../datatype/ClusterId.js";
+import { TlvEndpointNumber } from "../datatype/EndpointNumber.js";
 /**
  * Provides information about endpoint conformance to a release of a device type definition.
  *
@@ -17,7 +17,7 @@ import { TlvArray } from "../tlv/TlvArray.js";
  */
 const TlvDeviceType = TlvObject({
     /** Indicates the device type definition */
-    type: TlvField(0, TlvDeviceTypeId),
+    deviceType: TlvField(0, TlvDeviceTypeId),
     /** Indicates the implemented revision of the device type definition */
     revision: TlvField(1, TlvUInt16.bound({ min: 1 })),
 });
@@ -40,11 +40,11 @@ export const DescriptorCluster = Cluster({
         /** List containing each cluster ID for the server clusters present on the endpoint instance. */
         serverList: Attribute(1, TlvArray(TlvClusterId), { default: [] }),
         /** List containing each cluster ID for the client clusters present on the endpoint instance. */
-        clientList: Attribute(3, TlvArray(TlvClusterId), { default: [] }),
+        clientList: Attribute(2, TlvArray(TlvClusterId), { default: [] }),
         /**
          * This indicates composition of the device type instance. Device type instance composition SHALL
          * include the endpoints in this list.
          */
-        partsList: Attribute(4, TlvArray(TlvEndpointNumber), { default: [] }),
+        partsList: Attribute(3, TlvArray(TlvEndpointNumber), { default: [] }),
     },
 });

package/dist/es/cluster/FlowMeasurementCluster.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, OptionalAttribute, Cluster } from "./Cluster.js";
+/**
+ * This cluster provides an interface to flow measurement functionality.
+ *
+ * @see {@link MatterApplicationClusterSpecificationV1_0} § 2.5
+ */
+export declare const FlowMeasurementCluster: Cluster<import("../schema/BitmapSchema.js").BitSchema, {
+    measuredValue: Attribute<number | null>;
+    minMeasuredValue: Attribute<number | null>;
+    maxMeasuredValue: Attribute<number | null>;
+    tolerance: OptionalAttribute<number>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<import("../schema/BitmapSchema.js").BitSchema>>;
+    attributeList: Attribute<import("../datatype/AttributeId.js").AttributeId[]>;
+    eventList: Attribute<import("../datatype/EventId.js").EventId[]>;
+    acceptedCommandList: Attribute<import("../datatype/CommandId.js").CommandId[]>;
+    generatedCommandList: Attribute<import("../datatype/CommandId.js").CommandId[]>;
+}, import("./Cluster.js").Commands, import("./Cluster.js").Events>;
+//# sourceMappingURL=FlowMeasurementCluster.d.ts.map

package/dist/es/cluster/FlowMeasurementCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowMeasurementCluster.d.ts","sourceRoot":"","sources":["../../../src/cluster/FlowMeasurementCluster.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKrE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;kEAkBjC,CAAC"}

package/dist/es/cluster/FlowMeasurementCluster.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, OptionalAttribute, Cluster } from "./Cluster.js";
+import { TlvNullable } from "../tlv/TlvNullable.js";
+import { TlvUInt16 } from "../tlv/TlvNumber.js";
+/**
+ * This cluster provides an interface to flow measurement functionality.
+ *
+ * @see {@link MatterApplicationClusterSpecificationV1_0} § 2.5
+ */
+export const FlowMeasurementCluster = Cluster({
+    id: 0x0404,
+    name: "FlowMeasurement",
+    revision: 3,
+    /** @see {@link MatterApplicationClusterSpecificationV1_0} § 2.5.4 */
+    attributes: {
+        /** MeasuredValue represents the flow in m3 /h as follows: MeasuredValue = 10 x Flow  */
+        measuredValue: Attribute(0, TlvNullable(TlvUInt16), { default: null }),
+        /** Indicates the minimum value of MeasuredValue that can be measured.  */
+        minMeasuredValue: Attribute(1, TlvNullable(TlvUInt16)),
+        /** Indicates the maximum value of MeasuredValue that can be measured.  */
+        maxMeasuredValue: Attribute(2, TlvNullable(TlvUInt16.bound({ max: 65534 }))),
+        tolerance: OptionalAttribute(3, TlvUInt16.bound({ max: 2048 /* 0x0800 */ }), { default: 0 }),
+    },
+});

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

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2022-2023 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("../schema/BitmapSchema.js").BitSchema, {
+    breadcrumb: WritableAttribute<number | bigint>;
+    basicCommissioningInfo: Attribute<{
+        failSafeExpiryLengthSeconds: number;
+        maxCumulativeFailsafeSeconds: number;
+    }>;
+    regulatoryConfig: Attribute<RegulatoryLocationType>;
+    locationCapability: Attribute<RegulatoryLocationType>;
+    supportsConcurrentConnections: Attribute<boolean>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<import("../schema/BitmapSchema.js").BitSchema>>;
+    attributeList: Attribute<import("../datatype/AttributeId.js").AttributeId[]>;
+    eventList: Attribute<import("../datatype/EventId.js").EventId[]>;
+    acceptedCommandList: Attribute<import("../datatype/CommandId.js").CommandId[]>;
+    generatedCommandList: Attribute<import("../datatype/CommandId.js").CommandId[]>;
+}, {
+    /** Arms the persistent fail-safe timer with an expiry time of now + ExpiryLengthSeconds using device clock. */
+    armFailSafe: Command<{
+        expiryLengthSeconds: number;
+        breadcrumb: number | bigint;
+    }, {
+        errorCode: CommissioningError;
+        debugText: string;
+    }>;
+    /** Sets or Updates the regulatory configuration to be used during commissioning. */
+    setRegulatoryConfig: Command<{
+        breadcrumb: 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<void, {
+        errorCode: CommissioningError;
+        debugText: string;
+    }>;
+}, import("./Cluster.js").Events>;
+export {};
+//# sourceMappingURL=GeneralCommissioningCluster.d.ts.map

package/dist/es/cluster/GeneralCommissioningCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneralCommissioningCluster.d.ts","sourceRoot":"","sources":["../../../src/cluster/GeneralCommissioningCluster.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAe,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAK3F,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIrD;;;;GAIG;AACH,0BAAkB,sBAAsB;IACpC,kBAAkB;IAClB,MAAM,IAAI;IAEV,mBAAmB;IACnB,OAAO,IAAI;IAEX,qBAAqB;IACrB,aAAa,IAAI;CACpB;AAED;;;;GAIG;AACH,0BAAkB,kBAAkB;IAChC,gBAAgB;IAChB,EAAE,IAAI;IAEN,6IAA6I;IAC7I,iBAAiB,IAAI;IAErB,2DAA2D;IAC3D,qBAAqB,IAAI;IAEzB,iFAAiF;IACjF,UAAU,IAAI;IAEd,uJAAuJ;IACvJ,kBAAkB,IAAI;CACzB;AAeD;;;;;GAKG;AACH,QAAA,MAAM,sCAAsC;IACxC,2CAA2C;;IAG3C,mHAAmH;;EAErH,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,cAAc,CAAC,OAAO,sCAAsC,CAAC,CAAC;AAuBhH;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;IA2BhC,+GAA+G;;;;;;;;IAG/G,oFAAoF;;;;;;;;;IAGpF;;;OAGG;;;;;iCAGT,CAAC"}

package/dist/es/cluster/GeneralCommissioningCluster.js

@@ -1,13 +1,14 @@
 /**
  * @license
- * Copyright 2022 Project CHIP Authors
+ * Copyright 2022-2023 Project CHIP Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Attribute, Cluster, Command, TlvNoArguments, WritableAttribute } from "./Cluster.js";
+import { Attribute, Cluster, Command, WritableAttribute } from "./Cluster.js";
 import { TlvField, TlvObject } from "../tlv/TlvObject.js";
 import { TlvEnum, TlvUInt16, TlvUInt64 } from "../tlv/TlvNumber.js";
 import { TlvString } from "../tlv/TlvString.js";
 import { TlvBoolean } from "../tlv/TlvBoolean.js";
+import { TlvNoArguments } from "../tlv/TlvNoArguments.js";
 /**
  * This structure provides some constant values that MAY be of use to all commissioners.
  *
@@ -36,7 +37,7 @@ const TlvArmFailSafeRequest = TlvObject({
     /** Contains timeframe for fail-safe timer actions. */
     expiryLengthSeconds: TlvField(0, TlvUInt16),
     /** Value to atomically set the Breadcrumb attribute on success of this command. */
-    breadcrumbStep: TlvField(1, TlvUInt64),
+    breadcrumb: TlvField(1, TlvUInt64),
 });
 /** @see {@link MatterCoreSpecificationV1_0} § 11.9.7.4 */
 const TlvSetRegulatoryConfigRequest = TlvObject({
@@ -45,7 +46,7 @@ const TlvSetRegulatoryConfigRequest = TlvObject({
     /** Contains a ISO 3166-1 alpha-2 country code*/
     countryCode: TlvField(1, TlvString.bound({ length: 2 })),
     /** Value to atomically set the Breadcrumb attribute on success of this command. */
-    breadcrumbStep: TlvField(2, TlvUInt64),
+    breadcrumb: TlvField(2, TlvUInt64),
 });
 /**
  * This cluster is used to manage global aspects of the Commissioning flow.
@@ -54,7 +55,7 @@ const TlvSetRegulatoryConfigRequest = TlvObject({
  */
 export const GeneralCommissioningCluster = Cluster({
     id: 0x30,
-    name: "General Commissioning",
+    name: "GeneralCommissioning",
     revision: 1,
     /** @see {@link MatterCoreSpecificationV1_0} § 11.9.6 */
     attributes: {
@@ -63,7 +64,7 @@ export const GeneralCommissioningCluster = Cluster({
          */
         breadcrumb: WritableAttribute(0, TlvUInt64, { default: BigInt(0), writeAcl: 2 /* AccessLevel.Administer */ }),
         /** Describe critical parameters needed at the beginning of commissioning flow. */
-        commissioningInfo: Attribute(1, TlvBasicCommissioningInfo),
+        basicCommissioningInfo: Attribute(1, TlvBasicCommissioningInfo),
         /** Indicates the regulatory configuration for the product. */
         regulatoryConfig: Attribute(2, TlvEnum()),
         /** Indicates if this Node needs to be told an exact RegulatoryLocation. */
@@ -81,6 +82,6 @@ export const GeneralCommissioningCluster = Cluster({
          * Informs that all steps of Commissioning/Reconfiguration needed during the fail-safe period have been
          * completed.
          */
-        commissioningComplete: Command(4, TlvNoArguments, 5, TlvCommissioningSuccessFailureResponse),
+        commissioningComplete: Command(4, TlvNoArguments, 5, TlvCommissioningSuccessFailureResponse), /* fabricScoped: true */
     },
 });

package/dist/es/cluster/GeneralDiagnosticsCluster.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Command, Attribute, Cluster, Event, OptionalAttribute } from "./Cluster.js";
+/** @see {@link MatterCoreSpecificationV1_0} § 11.11.6.1 */
+export declare const enum HardwareFault {
+    Unspecified = 0,
+    Radio = 1,
+    Sensor = 2,
+    ResettableOverTemp = 3,
+    NonResettableOverTemp = 4,
+    PowerSource = 5,
+    VisualDisplayFault = 6,
+    AudioOutputFault = 7,
+    UserInterfaceFault = 8,
+    NonVolatileMemoryError = 9,
+    TamperDetected = 10
+}
+/** @see {@link MatterCoreSpecificationV1_0} § 11.11.6.2 */
+export declare const enum RadioFault {
+    Unspecified = 0,
+    WiFiFault = 1,
+    CellularFault = 2,
+    ThreadFault = 3,
+    NFCFault = 4,
+    BLEFault = 5,
+    EthernetFault = 6
+}
+/** @see {@link MatterCoreSpecificationV1_0} § 11.11.6.3 */
+export declare const enum NetworkFault {
+    Unspecified = 0,
+    HardwareFailure = 1,
+    NetworkJammed = 2,
+    ConnectionFaile = 3
+}
+/** @see {@link MatterCoreSpecificationV1_0} § 11.11.6.4 */
+export declare const enum InterfaceType {
+    Unspecified = 0,
+    WiFi = 1,
+    Ethernet = 2,
+    Celluar = 3,
+    Thread = 4
+}
+/** @see {@link MatterCoreSpecificationV1_0} § 11.11.7.5 */
+export declare const enum BootReason {
+    Unspecified = 0,
+    PowerOnReboot = 1,
+    BrownOutReset = 2,
+    SoftwareWatchdogReset = 3,
+    HardwareWatchdogReset = 4,
+    SoftwareUpdateCompleted = 5,
+    SoftwareReset = 6
+}
+/**
+ * The General Diagnostics Cluster, along with other diagnostics clusters, provide a means to acquire
+ * standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrator in
+ * diagnosing potential problems. The General Diagnostics Cluster attempts to centralize all metrics
+ * that are broadly relevant to the majority of Nodes.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11
+ */
+export declare const GeneralDiagnosticsCluster: Cluster<import("../schema/BitmapSchema.js").BitSchema, {
+    networkInterfaces: Attribute<{
+        type: InterfaceType;
+        name: string;
+        isOperational: boolean;
+        offPremiseServicesReachableIPv4: boolean | null;
+        offPremiseServicesReachableIPv6: boolean | null;
+        hardwareAddress: string;
+        iPv4Addresses: string[];
+        iPv6Addresse: string[];
+    }[]>;
+    rebootCount: Attribute<number>;
+    upTime: OptionalAttribute<number | bigint>;
+    totalOperationalHours: OptionalAttribute<number>;
+    bootReason: OptionalAttribute<BootReason>;
+    activeHardwareFaults: OptionalAttribute<HardwareFault[]>;
+    activeRadioFaults: OptionalAttribute<RadioFault[]>;
+    activeNetworkFaults: OptionalAttribute<NetworkFault[]>;
+    testEventTriggersEnabled: Attribute<boolean>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<import("../schema/BitmapSchema.js").BitSchema>>;
+    attributeList: Attribute<import("../datatype/AttributeId.js").AttributeId[]>;
+    eventList: Attribute<import("../datatype/EventId.js").EventId[]>;
+    acceptedCommandList: Attribute<import("../datatype/CommandId.js").CommandId[]>;
+    generatedCommandList: Attribute<import("../datatype/CommandId.js").CommandId[]>;
+}, {
+    /** Provide a means for certification tests to trigger some test-plan-specific events. */
+    testEventTrigger: Command<{
+        enableKey: string;
+        eventTrigger: number | bigint;
+    }, void>;
+}, {
+    /** Indicates a change in the set of hardware faults currently detected by the Node. */
+    hardwareFaultChange: Event<{
+        current: HardwareFault[];
+        previous: HardwareFault[];
+    }>;
+    /** Indicates a change in the set of radio faults currently detected by the Node. */
+    radioFaultChange: Event<{
+        current: HardwareFault[];
+        previous: HardwareFault[];
+    }>;
+    /** Indicates a change in the set of network faults currently detected by the Node. */
+    networkFaultChange: Event<{
+        current: HardwareFault[];
+        previous: HardwareFault[];
+    }>;
+    /** Indicate the reason that caused the device to start-up. */
+    bootReason: Event<{
+        bootReason: BootReason;
+    }>;
+}>;
+//# sourceMappingURL=GeneralDiagnosticsCluster.d.ts.map

package/dist/es/cluster/GeneralDiagnosticsCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneralDiagnosticsCluster.d.ts","sourceRoot":"","sources":["../../../src/cluster/GeneralDiagnosticsCluster.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAiB,iBAAiB,EAAgC,MAAM,cAAc,CAAC;AASlI,2DAA2D;AAC3D,0BAAkB,aAAa;IAC3B,WAAW,IAAO;IAClB,KAAK,IAAO;IACZ,MAAM,IAAO;IACb,kBAAkB,IAAO;IACzB,qBAAqB,IAAO;IAC5B,WAAW,IAAO;IAClB,kBAAkB,IAAO;IACzB,gBAAgB,IAAO;IACvB,kBAAkB,IAAO;IACzB,sBAAsB,IAAO;IAC7B,cAAc,KAAO;CACxB;AAED,2DAA2D;AAC3D,0BAAkB,UAAU;IACxB,WAAW,IAAO;IAClB,SAAS,IAAO;IAChB,aAAa,IAAO;IACpB,WAAW,IAAO;IAClB,QAAQ,IAAO;IACf,QAAQ,IAAO;IACf,aAAa,IAAO;CACvB;AAED,2DAA2D;AAC3D,0BAAkB,YAAY;IAC1B,WAAW,IAAO;IAClB,eAAe,IAAO;IACtB,aAAa,IAAO;IACpB,eAAe,IAAO;CACzB;AAED,2DAA2D;AAC3D,0BAAkB,aAAa;IAC3B,WAAW,IAAO;IAClB,IAAI,IAAO;IACX,QAAQ,IAAO;IACf,OAAO,IAAO;IACd,MAAM,IAAO;CAChB;AAED,2DAA2D;AAC3D,0BAAkB,UAAU;IACxB,WAAW,IAAO;IAClB,aAAa,IAAO;IACpB,aAAa,IAAO;IACpB,qBAAqB,IAAO;IAC5B,qBAAqB,IAAO;IAC5B,uBAAuB,IAAO;IAC9B,aAAa,IAAO;CACvB;AA+ED;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;IAsC9B,yFAAyF;;;;;;IAMzF,uFAAuF;;;;;IAGvF,oFAAoF;;;;;IAGpF,sFAAsF;;;;;IAGtF,8DAA8D;;;;EAGpE,CAAC"}

package/dist/es/cluster/GeneralDiagnosticsCluster.js

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * Copyright 2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Command, Attribute, Cluster, Event, OptionalAttribute, OptionalEvent, TlvNoResponse } from "./Cluster.js";
+import { TlvField, TlvObject } from "../tlv/TlvObject.js";
+import { TlvString, TlvString32max } from "../tlv/TlvString.js";
+import { TlvBoolean } from "../tlv/TlvBoolean.js";
+import { TlvNullable } from "../tlv/TlvNullable.js";
+import { TlvArray } from "../tlv/TlvArray.js";
+import { TlvEnum, TlvUInt16, TlvUInt32, TlvUInt64 } from "../tlv/TlvNumber.js";
+/**
+ * Describes a network interface supported by the Node, as provided in the NetworkInterfaces attribute.
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11.6.5
+ */
+const TlvNetworkInterface = TlvObject({
+    /** Human-readable (displayable) name for the network interface. */
+    name: TlvField(0, TlvString32max),
+    /** Indicates if the Node is currently advertising itself operationally on this network interface. */
+    isOperational: TlvField(1, TlvBoolean),
+    /** Indicates whether the Node is currently able to reach off-premise services it uses by utilizing IPv4. */
+    offPremiseServicesReachableIPv4: TlvField(2, TlvNullable(TlvBoolean)),
+    /** Indicates whether the Node is currently able to reach off-premise services it uses by utilizing IPv4. */
+    offPremiseServicesReachableIPv6: TlvField(3, TlvNullable(TlvBoolean)),
+    /**
+     * Contains the current link-layer address for a 802.3 or IEEE 802.11-2020 network interface and
+     * contains the current extended MAC address for a 802.15.4 interface.
+     */
+    hardwareAddress: TlvField(4, TlvString.bound({ maxLength: 8 })),
+    /** List of the IPv4 addresses that are currently assigned to the network interface. */
+    iPv4Addresses: TlvField(5, TlvArray(TlvString.bound({ maxLength: 4 }))),
+    /** List of the unicast IPv6 addresses that are currently assigned to the network interface. */
+    iPv6Addresse: TlvField(6, TlvArray(TlvString.bound({ maxLength: 8 }))),
+    /** Indicates the type of the interface. */
+    type: TlvField(7, TlvEnum()),
+});
+/**
+ * Indicates a change in the set of hardware faults currently detected by the Node.
+ * @see {@link MatterCoreSpecificationV1_0} §11.11.9.1
+ */
+const HardwareFaultChangeEventData = {
+    current: TlvField(0, TlvArray(TlvEnum(), { maxLength: 11 })),
+    previous: TlvField(1, TlvArray(TlvEnum(), { maxLength: 11 })),
+};
+/**
+ * Indicates a change in the set of radio faults currently detectedby the Node.
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11.9.2
+ */
+const RadioFaultChangeEventData = {
+    current: TlvField(0, TlvArray(TlvEnum(), { maxLength: 7 })),
+    previous: TlvField(1, TlvArray(TlvEnum(), { maxLength: 7 })),
+};
+/**
+ * Indicates a change in the set of network faults currently detected by the Node.
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11.9.3
+ */
+const NetworkFaultChangeEventData = {
+    current: TlvField(0, TlvArray(TlvEnum(), { maxLength: 4 })),
+    previous: TlvField(1, TlvArray(TlvEnum(), { maxLength: 4 })),
+};
+/**
+ * Indicates the reason that caused the device to start-up.
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11.7.4
+ */
+const BootReasonEvent = {
+    bootReason: TlvField(0, TlvEnum()),
+};
+/**
+ * Provides a means for certification tests to trigger some test-plan-specific events.
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11.8.1
+ */
+const TlvTestEventTriggerRequest = TlvObject({
+    enableKey: TlvField(0, TlvString.bound({ length: 16 })),
+    eventTrigger: TlvField(0, TlvUInt64)
+});
+/**
+ * The General Diagnostics Cluster, along with other diagnostics clusters, provide a means to acquire
+ * standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrator in
+ * diagnosing potential problems. The General Diagnostics Cluster attempts to centralize all metrics
+ * that are broadly relevant to the majority of Nodes.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11
+ */
+export const GeneralDiagnosticsCluster = Cluster({
+    id: 0x033,
+    name: "GeneralDiagnostics",
+    revision: 1,
+    /** @see {@link MatterCoreSpecificationV1_0} § 11.11.7 */
+    attributes: {
+        /** List of NetworkInterface structss */
+        networkInterfaces: Attribute(0, TlvArray(TlvNetworkInterface, { maxLength: 8 })),
+        /** Indicates a best-effort count of the number of times the Node has rebooted. */
+        rebootCount: Attribute(1, TlvUInt16, { default: 0, persistent: true }),
+        /** Indicates a best-effort assessment of the length of time, in seconds, since the Node’s last reboot. */
+        upTime: OptionalAttribute(2, TlvUInt64, { default: 0 }),
+        /** Indicates a best-effort attempt at time in hours the Node has been operational. */
+        totalOperationalHours: OptionalAttribute(3, TlvUInt32, { default: 0, persistent: true }),
+        /** Indicates the reason for the Node’s most recent boot */
+        bootReason: OptionalAttribute(4, TlvEnum()),
+        /** Indicates the set of faults currently detected by the Node. */
+        activeHardwareFaults: OptionalAttribute(5, TlvArray(TlvEnum(), { maxLength: 11 })),
+        /** Indicates the set of faults currently detected by the Node. */
+        activeRadioFaults: OptionalAttribute(6, TlvArray(TlvEnum(), { maxLength: 7 })),
+        /** Indicates the set of faults currently detected by the Node. */
+        activeNetworkFaults: OptionalAttribute(7, TlvArray(TlvEnum(), { maxLength: 4 })),
+        /** Indicates whether the Node has any TestEventTrigger configured. */
+        testEventTriggersEnabled: Attribute(8, TlvBoolean),
+    },
+    /** @see {@link MatterCoreSpecificationV1_0} § 11.11.8 */
+    commands: {
+        /** Provide a means for certification tests to trigger some test-plan-specific events. */
+        testEventTrigger: Command(0, TlvTestEventTriggerRequest, 0, TlvNoResponse),
+    },
+    /** @see {@link MatterCoreSpecificationV1_0} § 11.11.9 */
+    events: {
+        /** Indicates a change in the set of hardware faults currently detected by the Node. */
+        hardwareFaultChange: OptionalEvent(0, 0 /* EventPriority.Critical */, HardwareFaultChangeEventData),
+        /** Indicates a change in the set of radio faults currently detected by the Node. */
+        radioFaultChange: OptionalEvent(1, 0 /* EventPriority.Critical */, RadioFaultChangeEventData),
+        /** Indicates a change in the set of network faults currently detected by the Node. */
+        networkFaultChange: OptionalEvent(2, 0 /* EventPriority.Critical */, NetworkFaultChangeEventData),
+        /** Indicate the reason that caused the device to start-up. */
+        bootReason: Event(3, 0 /* EventPriority.Critical */, BootReasonEvent),
+    }
+});