@project-chip/matter.js 0.2.0 → 0.3.0

package/dist/cjs/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/cjs/cluster/ClusterHelper.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClusterAttributeById = exports.getClusterById = exports.AllClustersMap = void 0;
+const AccessControlCluster_js_1 = require("./AccessControlCluster.js");
+const ActionsCluster_js_1 = require("./ActionsCluster.js");
+const AdminCommissioningCluster_js_1 = require("./AdminCommissioningCluster.js");
+const BasicInformationCluster_js_1 = require("./BasicInformationCluster.js");
+const BindingCluster_js_1 = require("./BindingCluster.js");
+const BooleanStateCluster_js_1 = require("./BooleanStateCluster.js");
+const BridgedDeviceBasicInformationCluster_js_1 = require("./BridgedDeviceBasicInformationCluster.js");
+const DescriptorCluster_js_1 = require("./DescriptorCluster.js");
+const FlowMeasurementCluster_js_1 = require("./FlowMeasurementCluster.js");
+const GeneralCommissioningCluster_js_1 = require("./GeneralCommissioningCluster.js");
+const GroupsCluster_js_1 = require("./GroupsCluster.js");
+const IdentifyCluster_js_1 = require("./IdentifyCluster.js");
+const IlluminanceMeasurementCluster_js_1 = require("./IlluminanceMeasurementCluster.js");
+const LabelCluster_js_1 = require("./LabelCluster.js");
+const LevelControlCluster_js_1 = require("./LevelControlCluster.js");
+const NetworkCommissioningCluster_js_1 = require("./NetworkCommissioningCluster.js");
+const OccupancySensingCluster_js_1 = require("./OccupancySensingCluster.js");
+const OnOffCluster_js_1 = require("./OnOffCluster.js");
+const OperationalCredentialsCluster_js_1 = require("./OperationalCredentialsCluster.js");
+const PowerSourceCluster_js_1 = require("./PowerSourceCluster.js");
+const PowerSourceConfigurationCluster_js_1 = require("./PowerSourceConfigurationCluster.js");
+const PressureMeasurementCluster_js_1 = require("./PressureMeasurementCluster.js");
+const ScenesCluster_js_1 = require("./ScenesCluster.js");
+const TemperatureMeasurementCluster_js_1 = require("./TemperatureMeasurementCluster.js");
+const WaterContentMeasurementCluster_js_1 = require("./WaterContentMeasurementCluster.js");
+const GeneralDiagnosticsCluster_js_1 = require("./GeneralDiagnosticsCluster.js");
+const GroupKeyManagementCluster_js_1 = require("./GroupKeyManagementCluster.js");
+exports.AllClustersMap = {
+    [AccessControlCluster_js_1.AccessControlCluster.id]: AccessControlCluster_js_1.AccessControlCluster,
+    [ActionsCluster_js_1.ActionsCluster.id]: ActionsCluster_js_1.ActionsCluster,
+    [AdminCommissioningCluster_js_1.AdminCommissioningCluster.id]: AdminCommissioningCluster_js_1.AdminCommissioningCluster,
+    [BasicInformationCluster_js_1.BasicInformationCluster.id]: BasicInformationCluster_js_1.BasicInformationCluster,
+    [BindingCluster_js_1.BindingCluster.id]: BindingCluster_js_1.BindingCluster,
+    [BooleanStateCluster_js_1.BooleanStateCluster.id]: BooleanStateCluster_js_1.BooleanStateCluster,
+    [BridgedDeviceBasicInformationCluster_js_1.BridgedDeviceBasicInformationCluster.id]: BridgedDeviceBasicInformationCluster_js_1.BridgedDeviceBasicInformationCluster,
+    [DescriptorCluster_js_1.DescriptorCluster.id]: DescriptorCluster_js_1.DescriptorCluster,
+    [FlowMeasurementCluster_js_1.FlowMeasurementCluster.id]: FlowMeasurementCluster_js_1.FlowMeasurementCluster,
+    [GeneralCommissioningCluster_js_1.GeneralCommissioningCluster.id]: GeneralCommissioningCluster_js_1.GeneralCommissioningCluster,
+    [GeneralDiagnosticsCluster_js_1.GeneralDiagnosticsCluster.id]: GeneralDiagnosticsCluster_js_1.GeneralDiagnosticsCluster,
+    [GroupKeyManagementCluster_js_1.GroupKeyManagementCluster.id]: GroupKeyManagementCluster_js_1.GroupKeyManagementCluster,
+    [GroupsCluster_js_1.GroupsCluster.id]: GroupsCluster_js_1.GroupsCluster,
+    [IdentifyCluster_js_1.IdentifyCluster.id]: IdentifyCluster_js_1.IdentifyCluster,
+    [IlluminanceMeasurementCluster_js_1.IlluminanceMeasurementCluster.id]: IlluminanceMeasurementCluster_js_1.IlluminanceMeasurementCluster,
+    [LabelCluster_js_1.UserLabelCluster.id]: LabelCluster_js_1.UserLabelCluster,
+    [LabelCluster_js_1.FixedLabelCluster.id]: LabelCluster_js_1.FixedLabelCluster,
+    [LevelControlCluster_js_1.LevelControlCluster.id]: LevelControlCluster_js_1.LevelControlCluster,
+    [NetworkCommissioningCluster_js_1.NetworkCommissioningCluster.id]: NetworkCommissioningCluster_js_1.NetworkCommissioningCluster,
+    [OccupancySensingCluster_js_1.OccupancySensingCluster.id]: OccupancySensingCluster_js_1.OccupancySensingCluster,
+    [OnOffCluster_js_1.OnOffCluster.id]: OnOffCluster_js_1.OnOffCluster,
+    [OperationalCredentialsCluster_js_1.OperationalCredentialsCluster.id]: OperationalCredentialsCluster_js_1.OperationalCredentialsCluster,
+    [PowerSourceCluster_js_1.PowerSourceCluster.id]: PowerSourceCluster_js_1.PowerSourceCluster,
+    [PowerSourceConfigurationCluster_js_1.PowerSourceConfigurationCluster.id]: PowerSourceConfigurationCluster_js_1.PowerSourceConfigurationCluster,
+    [PressureMeasurementCluster_js_1.PressureMeasurementCluster.id]: PressureMeasurementCluster_js_1.PressureMeasurementCluster,
+    [ScenesCluster_js_1.ScenesCluster.id]: ScenesCluster_js_1.ScenesCluster,
+    [TemperatureMeasurementCluster_js_1.TemperatureMeasurementCluster.id]: TemperatureMeasurementCluster_js_1.TemperatureMeasurementCluster,
+    [WaterContentMeasurementCluster_js_1.RelativeHumidityCluster.id]: WaterContentMeasurementCluster_js_1.RelativeHumidityCluster,
+    [WaterContentMeasurementCluster_js_1.LeafWetnessMeasurementCluster.id]: WaterContentMeasurementCluster_js_1.LeafWetnessMeasurementCluster,
+    [WaterContentMeasurementCluster_js_1.SoilMoistureMeasurementCluster.id]: WaterContentMeasurementCluster_js_1.SoilMoistureMeasurementCluster,
+};
+const clusterAttributeCache = new Map();
+function getClusterById(clusterId) {
+    return exports.AllClustersMap[clusterId];
+}
+exports.getClusterById = getClusterById;
+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);
+}
+exports.getClusterAttributeById = getClusterAttributeById;

package/dist/cjs/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/cjs/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/cjs/cluster/DescriptorCluster.js

@@ -1,18 +1,18 @@
 "use strict";
 /**
  * @license
- * Copyright 2022 Project CHIP Authors
+ * Copyright 2022-2023 Project CHIP Authors
  * SPDX-License-Identifier: Apache-2.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DescriptorCluster = void 0;
 const Cluster_js_1 = require("./Cluster.js");
-const DeviceTypeId_js_1 = require("../common/DeviceTypeId.js");
-const ClusterId_js_1 = require("../common/ClusterId.js");
-const EndpointNumber_js_1 = require("../common/EndpointNumber.js");
 const TlvObject_js_1 = require("../tlv/TlvObject.js");
+const DeviceTypeId_js_1 = require("../datatype/DeviceTypeId.js");
 const TlvNumber_js_1 = require("../tlv/TlvNumber.js");
 const TlvArray_js_1 = require("../tlv/TlvArray.js");
+const ClusterId_js_1 = require("../datatype/ClusterId.js");
+const EndpointNumber_js_1 = require("../datatype/EndpointNumber.js");
 /**
  * Provides information about endpoint conformance to a release of a device type definition.
  *
@@ -20,7 +20,7 @@ const TlvArray_js_1 = require("../tlv/TlvArray.js");
  */
 const TlvDeviceType = (0, TlvObject_js_1.TlvObject)({
     /** Indicates the device type definition */
-    type: (0, TlvObject_js_1.TlvField)(0, DeviceTypeId_js_1.TlvDeviceTypeId),
+    deviceType: (0, TlvObject_js_1.TlvField)(0, DeviceTypeId_js_1.TlvDeviceTypeId),
     /** Indicates the implemented revision of the device type definition */
     revision: (0, TlvObject_js_1.TlvField)(1, TlvNumber_js_1.TlvUInt16.bound({ min: 1 })),
 });
@@ -43,11 +43,11 @@ exports.DescriptorCluster = (0, Cluster_js_1.Cluster)({
         /** List containing each cluster ID for the server clusters present on the endpoint instance. */
         serverList: (0, Cluster_js_1.Attribute)(1, (0, TlvArray_js_1.TlvArray)(ClusterId_js_1.TlvClusterId), { default: [] }),
         /** List containing each cluster ID for the client clusters present on the endpoint instance. */
-        clientList: (0, Cluster_js_1.Attribute)(3, (0, TlvArray_js_1.TlvArray)(ClusterId_js_1.TlvClusterId), { default: [] }),
+        clientList: (0, Cluster_js_1.Attribute)(2, (0, TlvArray_js_1.TlvArray)(ClusterId_js_1.TlvClusterId), { default: [] }),
         /**
          * This indicates composition of the device type instance. Device type instance composition SHALL
          * include the endpoints in this list.
          */
-        partsList: (0, Cluster_js_1.Attribute)(4, (0, TlvArray_js_1.TlvArray)(EndpointNumber_js_1.TlvEndpointNumber), { default: [] }),
+        partsList: (0, Cluster_js_1.Attribute)(3, (0, TlvArray_js_1.TlvArray)(EndpointNumber_js_1.TlvEndpointNumber), { default: [] }),
     },
 });

package/dist/cjs/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/cjs/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/cjs/cluster/FlowMeasurementCluster.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowMeasurementCluster = void 0;
+const Cluster_js_1 = require("./Cluster.js");
+const TlvNullable_js_1 = require("../tlv/TlvNullable.js");
+const TlvNumber_js_1 = require("../tlv/TlvNumber.js");
+/**
+ * This cluster provides an interface to flow measurement functionality.
+ *
+ * @see {@link MatterApplicationClusterSpecificationV1_0} § 2.5
+ */
+exports.FlowMeasurementCluster = (0, Cluster_js_1.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: (0, Cluster_js_1.Attribute)(0, (0, TlvNullable_js_1.TlvNullable)(TlvNumber_js_1.TlvUInt16), { default: null }),
+        /** Indicates the minimum value of MeasuredValue that can be measured.  */
+        minMeasuredValue: (0, Cluster_js_1.Attribute)(1, (0, TlvNullable_js_1.TlvNullable)(TlvNumber_js_1.TlvUInt16)),
+        /** Indicates the maximum value of MeasuredValue that can be measured.  */
+        maxMeasuredValue: (0, Cluster_js_1.Attribute)(2, (0, TlvNullable_js_1.TlvNullable)(TlvNumber_js_1.TlvUInt16.bound({ max: 65534 }))),
+        tolerance: (0, Cluster_js_1.OptionalAttribute)(3, TlvNumber_js_1.TlvUInt16.bound({ max: 2048 /* 0x0800 */ }), { default: 0 }),
+    },
+});

package/dist/{dts → cjs}/cluster/GeneralCommissioningCluster.d.ts

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright 2022 Project CHIP Authors
+ * Copyright 2022-2023 Project CHIP Authors
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Attribute, Cluster, Command, WritableAttribute } from "./Cluster.js";
@@ -53,9 +53,9 @@ export type CommissioningSuccessFailureResponse = TypeFromSchema<typeof TlvCommi
  *
  * @see {@link MatterCoreSpecificationV1_0} § 11.9
  */
-export declare const GeneralCommissioningCluster: Cluster<import("../matter.js").BitSchema, {
+export declare const GeneralCommissioningCluster: Cluster<import("../schema/BitmapSchema.js").BitSchema, {
     breadcrumb: WritableAttribute<number | bigint>;
-    commissioningInfo: Attribute<{
+    basicCommissioningInfo: Attribute<{
         failSafeExpiryLengthSeconds: number;
         maxCumulativeFailsafeSeconds: number;
     }>;
@@ -63,19 +63,23 @@ export declare const GeneralCommissioningCluster: Cluster<import("../matter.js")
     locationCapability: Attribute<RegulatoryLocationType>;
     supportsConcurrentConnections: Attribute<boolean>;
     clusterRevision: Attribute<number>;
-    featureMap: Attribute<import("../matter.js").TypeFromBitSchema<import("../matter.js").BitSchema>>;
+    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;
-        breadcrumbStep: number | bigint;
+        breadcrumb: number | bigint;
     }, {
         errorCode: CommissioningError;
         debugText: string;
     }>;
     /** Sets or Updates the regulatory configuration to be used during commissioning. */
     setRegulatoryConfig: Command<{
-        breadcrumbStep: number | bigint;
+        breadcrumb: number | bigint;
         newRegulatoryConfig: RegulatoryLocationType;
         countryCode: string;
     }, {
@@ -86,9 +90,10 @@ export declare const GeneralCommissioningCluster: Cluster<import("../matter.js")
      * Informs that all steps of Commissioning/Reconfiguration needed during the fail-safe period have been
      * completed.
      */
-    commissioningComplete: Command<{}, {
+    commissioningComplete: Command<void, {
         errorCode: CommissioningError;
         debugText: string;
     }>;
 }, import("./Cluster.js").Events>;
 export {};
+//# sourceMappingURL=GeneralCommissioningCluster.d.ts.map

package/dist/cjs/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/cjs/cluster/GeneralCommissioningCluster.js

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

package/dist/cjs/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/cjs/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/cjs/cluster/GeneralDiagnosticsCluster.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneralDiagnosticsCluster = void 0;
+const Cluster_js_1 = require("./Cluster.js");
+const TlvObject_js_1 = require("../tlv/TlvObject.js");
+const TlvString_js_1 = require("../tlv/TlvString.js");
+const TlvBoolean_js_1 = require("../tlv/TlvBoolean.js");
+const TlvNullable_js_1 = require("../tlv/TlvNullable.js");
+const TlvArray_js_1 = require("../tlv/TlvArray.js");
+const TlvNumber_js_1 = require("../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 = (0, TlvObject_js_1.TlvObject)({
+    /** Human-readable (displayable) name for the network interface. */
+    name: (0, TlvObject_js_1.TlvField)(0, TlvString_js_1.TlvString32max),
+    /** Indicates if the Node is currently advertising itself operationally on this network interface. */
+    isOperational: (0, TlvObject_js_1.TlvField)(1, TlvBoolean_js_1.TlvBoolean),
+    /** Indicates whether the Node is currently able to reach off-premise services it uses by utilizing IPv4. */
+    offPremiseServicesReachableIPv4: (0, TlvObject_js_1.TlvField)(2, (0, TlvNullable_js_1.TlvNullable)(TlvBoolean_js_1.TlvBoolean)),
+    /** Indicates whether the Node is currently able to reach off-premise services it uses by utilizing IPv4. */
+    offPremiseServicesReachableIPv6: (0, TlvObject_js_1.TlvField)(3, (0, TlvNullable_js_1.TlvNullable)(TlvBoolean_js_1.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: (0, TlvObject_js_1.TlvField)(4, TlvString_js_1.TlvString.bound({ maxLength: 8 })),
+    /** List of the IPv4 addresses that are currently assigned to the network interface. */
+    iPv4Addresses: (0, TlvObject_js_1.TlvField)(5, (0, TlvArray_js_1.TlvArray)(TlvString_js_1.TlvString.bound({ maxLength: 4 }))),
+    /** List of the unicast IPv6 addresses that are currently assigned to the network interface. */
+    iPv6Addresse: (0, TlvObject_js_1.TlvField)(6, (0, TlvArray_js_1.TlvArray)(TlvString_js_1.TlvString.bound({ maxLength: 8 }))),
+    /** Indicates the type of the interface. */
+    type: (0, TlvObject_js_1.TlvField)(7, (0, TlvNumber_js_1.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: (0, TlvObject_js_1.TlvField)(0, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.TlvEnum)(), { maxLength: 11 })),
+    previous: (0, TlvObject_js_1.TlvField)(1, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.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: (0, TlvObject_js_1.TlvField)(0, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.TlvEnum)(), { maxLength: 7 })),
+    previous: (0, TlvObject_js_1.TlvField)(1, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.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: (0, TlvObject_js_1.TlvField)(0, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.TlvEnum)(), { maxLength: 4 })),
+    previous: (0, TlvObject_js_1.TlvField)(1, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.TlvEnum)(), { maxLength: 4 })),
+};
+/**
+ * Indicates the reason that caused the device to start-up.
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11.7.4
+ */
+const BootReasonEvent = {
+    bootReason: (0, TlvObject_js_1.TlvField)(0, (0, TlvNumber_js_1.TlvEnum)()),
+};
+/**
+ * Provides a means for certification tests to trigger some test-plan-specific events.
+ * @see {@link MatterCoreSpecificationV1_0} § 11.11.8.1
+ */
+const TlvTestEventTriggerRequest = (0, TlvObject_js_1.TlvObject)({
+    enableKey: (0, TlvObject_js_1.TlvField)(0, TlvString_js_1.TlvString.bound({ length: 16 })),
+    eventTrigger: (0, TlvObject_js_1.TlvField)(0, TlvNumber_js_1.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
+ */
+exports.GeneralDiagnosticsCluster = (0, Cluster_js_1.Cluster)({
+    id: 0x033,
+    name: "GeneralDiagnostics",
+    revision: 1,
+    /** @see {@link MatterCoreSpecificationV1_0} § 11.11.7 */
+    attributes: {
+        /** List of NetworkInterface structss */
+        networkInterfaces: (0, Cluster_js_1.Attribute)(0, (0, TlvArray_js_1.TlvArray)(TlvNetworkInterface, { maxLength: 8 })),
+        /** Indicates a best-effort count of the number of times the Node has rebooted. */
+        rebootCount: (0, Cluster_js_1.Attribute)(1, TlvNumber_js_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: (0, Cluster_js_1.OptionalAttribute)(2, TlvNumber_js_1.TlvUInt64, { default: 0 }),
+        /** Indicates a best-effort attempt at time in hours the Node has been operational. */
+        totalOperationalHours: (0, Cluster_js_1.OptionalAttribute)(3, TlvNumber_js_1.TlvUInt32, { default: 0, persistent: true }),
+        /** Indicates the reason for the Node’s most recent boot */
+        bootReason: (0, Cluster_js_1.OptionalAttribute)(4, (0, TlvNumber_js_1.TlvEnum)()),
+        /** Indicates the set of faults currently detected by the Node. */
+        activeHardwareFaults: (0, Cluster_js_1.OptionalAttribute)(5, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.TlvEnum)(), { maxLength: 11 })),
+        /** Indicates the set of faults currently detected by the Node. */
+        activeRadioFaults: (0, Cluster_js_1.OptionalAttribute)(6, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.TlvEnum)(), { maxLength: 7 })),
+        /** Indicates the set of faults currently detected by the Node. */
+        activeNetworkFaults: (0, Cluster_js_1.OptionalAttribute)(7, (0, TlvArray_js_1.TlvArray)((0, TlvNumber_js_1.TlvEnum)(), { maxLength: 4 })),
+        /** Indicates whether the Node has any TestEventTrigger configured. */
+        testEventTriggersEnabled: (0, Cluster_js_1.Attribute)(8, TlvBoolean_js_1.TlvBoolean),
+    },
+    /** @see {@link MatterCoreSpecificationV1_0} § 11.11.8 */
+    commands: {
+        /** Provide a means for certification tests to trigger some test-plan-specific events. */
+        testEventTrigger: (0, Cluster_js_1.Command)(0, TlvTestEventTriggerRequest, 0, Cluster_js_1.TlvNoResponse),
+    },
+    /** @see {@link MatterCoreSpecificationV1_0} § 11.11.9 */
+    events: {
+        /** Indicates a change in the set of hardware faults currently detected by the Node. */
+        hardwareFaultChange: (0, Cluster_js_1.OptionalEvent)(0, 0 /* EventPriority.Critical */, HardwareFaultChangeEventData),
+        /** Indicates a change in the set of radio faults currently detected by the Node. */
+        radioFaultChange: (0, Cluster_js_1.OptionalEvent)(1, 0 /* EventPriority.Critical */, RadioFaultChangeEventData),
+        /** Indicates a change in the set of network faults currently detected by the Node. */
+        networkFaultChange: (0, Cluster_js_1.OptionalEvent)(2, 0 /* EventPriority.Critical */, NetworkFaultChangeEventData),
+        /** Indicate the reason that caused the device to start-up. */
+        bootReason: (0, Cluster_js_1.Event)(3, 0 /* EventPriority.Critical */, BootReasonEvent),
+    }
+});