@matter/node 0.15.1 → 0.15.2-alpha.0-20250704-2715344f0

package/dist/cjs/behaviors/pm25-concentration-measurement/Pm25ConcentrationMeasurementClient.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+import { Pm25ConcentrationMeasurement } from "#clusters/pm25-concentration-measurement";
+import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { Identity } from "#general";
+export declare const Pm25ConcentrationMeasurementClientConstructor: ClusterBehavior.Type<Pm25ConcentrationMeasurement.Complete, typeof ClusterBehavior, {
+    components: never[];
+}>;
+export interface Pm25ConcentrationMeasurementClient extends InstanceType<typeof Pm25ConcentrationMeasurementClientConstructor> {
+}
+export interface Pm25ConcentrationMeasurementClientConstructor extends Identity<typeof Pm25ConcentrationMeasurementClientConstructor> {
+}
+export declare const Pm25ConcentrationMeasurementClient: Pm25ConcentrationMeasurementClientConstructor;
+//# sourceMappingURL=Pm25ConcentrationMeasurementClient.d.ts.map

package/dist/cjs/behaviors/pm25-concentration-measurement/Pm25ConcentrationMeasurementClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pm25ConcentrationMeasurementClient.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/pm25-concentration-measurement/Pm25ConcentrationMeasurementClient.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AACxF,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,eAAO,MAAM,6CAA6C;;EAA6D,CAAC;AACxH,MAAM,WAAW,kCAAmC,SAAQ,YAAY,CAAC,OAAO,6CAA6C,CAAC;CAAG;AACjI,MAAM,WAAW,6CAA8C,SAAQ,QAAQ,CAAC,OAAO,6CAA6C,CAAC;CAAG;AACxI,eAAO,MAAM,kCAAkC,EAAE,6CAA6F,CAAC"}

package/dist/cjs/behaviors/pm25-concentration-measurement/Pm25ConcentrationMeasurementClient.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Pm25ConcentrationMeasurementClient_exports = {};
+__export(Pm25ConcentrationMeasurementClient_exports, {
+  Pm25ConcentrationMeasurementClient: () => Pm25ConcentrationMeasurementClient,
+  Pm25ConcentrationMeasurementClientConstructor: () => Pm25ConcentrationMeasurementClientConstructor
+});
+module.exports = __toCommonJS(Pm25ConcentrationMeasurementClient_exports);
+var import_pm25_concentration_measurement = require("#clusters/pm25-concentration-measurement");
+var import_ClusterBehavior = require("../../behavior/cluster/ClusterBehavior.js");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const Pm25ConcentrationMeasurementClientConstructor = import_ClusterBehavior.ClusterBehavior.for(import_pm25_concentration_measurement.Pm25ConcentrationMeasurement.Complete);
+const Pm25ConcentrationMeasurementClient = Pm25ConcentrationMeasurementClientConstructor;
+//# sourceMappingURL=Pm25ConcentrationMeasurementClient.js.map

package/dist/cjs/behaviors/pm25-concentration-measurement/Pm25ConcentrationMeasurementClient.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/behaviors/pm25-concentration-measurement/Pm25ConcentrationMeasurementClient.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,4CAA6C;AAC7C,6BAAgC;AAThC;AAAA;AAAA;AAAA;AAAA;AAYO,MAAM,gDAAgD,uCAAgB,IAAI,mEAA6B,QAAQ;AAG/G,MAAM,qCAAoF;",
+  "names": []
+}

package/dist/cjs/behaviors/pm25-concentration-measurement/index.d.ts

@@ -6,4 +6,5 @@
 /*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
 export * from "./Pm25ConcentrationMeasurementBehavior.js";
 export * from "./Pm25ConcentrationMeasurementServer.js";
+export * from "./Pm25ConcentrationMeasurementClient.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/behaviors/pm25-concentration-measurement/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/pm25-concentration-measurement/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yEAAyE;AAEzE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yCAAyC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/pm25-concentration-measurement/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yEAAyE;AAEzE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yCAAyC,CAAC;AACxD,cAAc,yCAAyC,CAAC"}

package/dist/cjs/behaviors/pm25-concentration-measurement/index.js

@@ -17,6 +17,7 @@ var pm25_concentration_measurement_exports = {};
 module.exports = __toCommonJS(pm25_concentration_measurement_exports);
 __reExport(pm25_concentration_measurement_exports, require("./Pm25ConcentrationMeasurementBehavior.js"), module.exports);
 __reExport(pm25_concentration_measurement_exports, require("./Pm25ConcentrationMeasurementServer.js"), module.exports);
+__reExport(pm25_concentration_measurement_exports, require("./Pm25ConcentrationMeasurementClient.js"), module.exports);
 /**
  * @license
  * Copyright 2022-2025 Matter.js Authors

package/dist/cjs/behaviors/pm25-concentration-measurement/index.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/behaviors/pm25-concentration-measurement/index.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAQA,mDAAc,sDARd;AASA,mDAAc,oDATd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAQA,mDAAc,sDARd;AASA,mDAAc,oDATd;AAUA,mDAAc,oDAVd;AAAA;AAAA;AAAA;AAAA;AAAA;",
   "names": []
 }

package/dist/cjs/behaviors/power-source/PowerSourceBehavior.d.ts

@@ -7,13 +7,14 @@
 import { PowerSource } from "#clusters/power-source";
 import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
 import { ClusterType } from "#types";
+import { Identity } from "#general";
 /**
  * PowerSourceBehavior is the base class for objects that support interaction with {@link PowerSource.Cluster}.
  *
  * PowerSource.Cluster requires you to enable one or more optional features. You can do so using
  * {@link PowerSourceBehavior.with}.
  */
-export declare const PowerSourceBehavior: ClusterBehavior.Type<ClusterType.Of<{
+export declare const PowerSourceBehaviorConstructor: ClusterBehavior.Type<ClusterType.Of<{
     readonly id: 47;
     readonly name: "PowerSource";
     readonly revision: 3;
@@ -152,13 +153,13 @@ export declare const PowerSourceBehavior: ClusterBehavior.Type<ClusterType.Of<{
 }>, typeof ClusterBehavior, {
     components: never[];
 }>;
-type PowerSourceBehaviorType = InstanceType<typeof PowerSourceBehavior>;
-export interface PowerSourceBehavior extends PowerSourceBehaviorType {
+export interface PowerSourceBehaviorConstructor extends Identity<typeof PowerSourceBehaviorConstructor> {
+}
+export declare const PowerSourceBehavior: PowerSourceBehaviorConstructor;
+export interface PowerSourceBehavior extends InstanceType<PowerSourceBehaviorConstructor> {
 }
-type StateType = InstanceType<typeof PowerSourceBehavior.State>;
 export declare namespace PowerSourceBehavior {
-    interface State extends StateType {
+    interface State extends InstanceType<typeof PowerSourceBehavior.State> {
     }
 }
-export {};
 //# sourceMappingURL=PowerSourceBehavior.d.ts.map

package/dist/cjs/behaviors/power-source/PowerSourceBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PowerSourceBehavior.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source/PowerSourceBehavior.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqD,CAAC;AAEtF,KAAK,uBAAuB,GAAG,YAAY,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACxE,MAAM,WAAW,mBAAoB,SAAQ,uBAAuB;CAAG;AACvE,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAChE,yBAAiB,mBAAmB,CAAC;IAAE,UAAiB,KAAM,SAAQ,SAAS;KAAG;CAAE"}
+{"version":3,"file":"PowerSourceBehavior.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source/PowerSourceBehavior.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqD,CAAC;AAEjG,MAAM,WAAW,8BAA+B,SAAQ,QAAQ,CAAC,OAAO,8BAA8B,CAAC;CAAG;AAC1G,eAAO,MAAM,mBAAmB,EAAE,8BAA+D,CAAC;AAClG,MAAM,WAAW,mBAAoB,SAAQ,YAAY,CAAC,8BAA8B,CAAC;CAAG;AAC5F,yBAAiB,mBAAmB,CAAC;IAAE,UAAiB,KAAM,SAAQ,YAAY,CAAC,OAAO,mBAAmB,CAAC,KAAK,CAAC;KAAG;CAAE"}

package/dist/cjs/behaviors/power-source/PowerSourceBehavior.js

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var PowerSourceBehavior_exports = {};
 __export(PowerSourceBehavior_exports, {
-  PowerSourceBehavior: () => PowerSourceBehavior
+  PowerSourceBehavior: () => PowerSourceBehavior,
+  PowerSourceBehaviorConstructor: () => PowerSourceBehaviorConstructor
 });
 module.exports = __toCommonJS(PowerSourceBehavior_exports);
 var import_power_source = require("#clusters/power-source");
@@ -29,5 +30,6 @@ var import_types = require("#types");
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-const PowerSourceBehavior = import_ClusterBehavior.ClusterBehavior.for((0, import_types.ClusterType)(import_power_source.PowerSource.Base));
+const PowerSourceBehaviorConstructor = import_ClusterBehavior.ClusterBehavior.for((0, import_types.ClusterType)(import_power_source.PowerSource.Base));
+const PowerSourceBehavior = PowerSourceBehaviorConstructor;
 //# sourceMappingURL=PowerSourceBehavior.js.map

package/dist/cjs/behaviors/power-source/PowerSourceBehavior.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/behaviors/power-source/PowerSourceBehavior.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,0BAA4B;AAC5B,6BAAgC;AAChC,mBAA4B;AAV5B;AAAA;AAAA;AAAA;AAAA;AAkBO,MAAM,sBAAsB,uCAAgB,QAAI,0BAAY,gCAAY,IAAI,CAAC;",
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,0BAA4B;AAC5B,6BAAgC;AAChC,mBAA4B;AAV5B;AAAA;AAAA;AAAA;AAAA;AAmBO,MAAM,iCAAiC,uCAAgB,QAAI,0BAAY,gCAAY,IAAI,CAAC;AAGxF,MAAM,sBAAsD;",
   "names": []
 }

package/dist/cjs/behaviors/power-source/PowerSourceClient.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+import { PowerSource } from "#clusters/power-source";
+import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { Identity } from "#general";
+export declare const PowerSourceClientConstructor: ClusterBehavior.Type<PowerSource.Complete, typeof ClusterBehavior, {
+    components: never[];
+}>;
+export interface PowerSourceClient extends InstanceType<typeof PowerSourceClientConstructor> {
+}
+export interface PowerSourceClientConstructor extends Identity<typeof PowerSourceClientConstructor> {
+}
+export declare const PowerSourceClient: PowerSourceClientConstructor;
+//# sourceMappingURL=PowerSourceClient.d.ts.map

package/dist/cjs/behaviors/power-source/PowerSourceClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PowerSourceClient.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source/PowerSourceClient.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,eAAO,MAAM,4BAA4B;;EAA4C,CAAC;AACtF,MAAM,WAAW,iBAAkB,SAAQ,YAAY,CAAC,OAAO,4BAA4B,CAAC;CAAG;AAC/F,MAAM,WAAW,4BAA6B,SAAQ,QAAQ,CAAC,OAAO,4BAA4B,CAAC;CAAG;AACtG,eAAO,MAAM,iBAAiB,EAAE,4BAA2D,CAAC"}

package/dist/cjs/behaviors/power-source/PowerSourceClient.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PowerSourceClient_exports = {};
+__export(PowerSourceClient_exports, {
+  PowerSourceClient: () => PowerSourceClient,
+  PowerSourceClientConstructor: () => PowerSourceClientConstructor
+});
+module.exports = __toCommonJS(PowerSourceClient_exports);
+var import_power_source = require("#clusters/power-source");
+var import_ClusterBehavior = require("../../behavior/cluster/ClusterBehavior.js");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const PowerSourceClientConstructor = import_ClusterBehavior.ClusterBehavior.for(import_power_source.PowerSource.Complete);
+const PowerSourceClient = PowerSourceClientConstructor;
+//# sourceMappingURL=PowerSourceClient.js.map

package/dist/cjs/behaviors/power-source/PowerSourceClient.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/behaviors/power-source/PowerSourceClient.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,0BAA4B;AAC5B,6BAAgC;AAThC;AAAA;AAAA;AAAA;AAAA;AAYO,MAAM,+BAA+B,uCAAgB,IAAI,gCAAY,QAAQ;AAG7E,MAAM,oBAAkD;",
+  "names": []
+}

package/dist/cjs/behaviors/power-source/PowerSourceServer.d.ts

@@ -141,145 +141,7 @@ declare const PowerSourceLevelBase: import("../../index.js").ClusterBehavior.Typ
         };
         readonly component: false;
     }];
-}>, readonly [PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable]>, import("../../index.js").ClusterBehavior.Type<ClusterType.Of<{
-    readonly id: 47;
-    readonly name: "PowerSource";
-    readonly revision: 3;
-    readonly features: {
-        readonly wired: import("#types").BitFlag;
-        readonly battery: import("#types").BitFlag;
-        readonly rechargeable: import("#types").BitFlag;
-        readonly replaceable: import("#types").BitFlag;
-    };
-    readonly attributes: {
-        readonly status: import("#types").Attribute<PowerSource.PowerSourceStatus, any>;
-        readonly order: import("#types").Attribute<number, any>;
-        readonly description: import("#types").FixedAttribute<string, any>;
-        readonly endpointList: import("#types").Attribute<import("#types").EndpointNumber[], any>;
-    };
-    readonly extensions: readonly [{
-        readonly flags: {
-            readonly wired: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly wiredAssessedInputVoltage: import("#types").OptionalAttribute<number | null, any>;
-                readonly wiredAssessedInputFrequency: import("#types").OptionalAttribute<number | null, any>;
-                readonly wiredCurrentType: import("#types").FixedAttribute<PowerSource.WiredCurrentType, any>;
-                readonly wiredAssessedCurrent: import("#types").OptionalAttribute<number | null, any>;
-                readonly wiredNominalVoltage: import("#types").OptionalFixedAttribute<number, any>;
-                readonly wiredMaximumCurrent: import("#types").OptionalFixedAttribute<number, any>;
-                readonly wiredPresent: import("#types").OptionalAttribute<boolean, any>;
-                readonly activeWiredFaults: import("#types").OptionalAttribute<PowerSource.WiredFault[], any>;
-            };
-            readonly events: {
-                readonly wiredFaultChange: import("#types").OptionalEvent<import("#types").TypeFromFields<{
-                    current: import("#types").FieldType<PowerSource.WiredFault[]>;
-                    previous: import("#types").FieldType<PowerSource.WiredFault[]>;
-                }>, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly battery: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly batVoltage: import("#types").OptionalAttribute<number | null, any>;
-                readonly batPercentRemaining: import("#types").OptionalAttribute<number | null, any>;
-                readonly batTimeRemaining: import("#types").OptionalAttribute<number | null, any>;
-                readonly batChargeLevel: import("#types").Attribute<PowerSource.BatChargeLevel, any>;
-                readonly batReplacementNeeded: import("#types").Attribute<boolean, any>;
-                readonly batReplaceability: import("#types").FixedAttribute<PowerSource.BatReplaceability, any>;
-                readonly batPresent: import("#types").OptionalAttribute<boolean, any>;
-                readonly activeBatFaults: import("#types").OptionalAttribute<PowerSource.BatFault[], any>;
-            };
-            readonly events: {
-                readonly batFaultChange: import("#types").OptionalEvent<import("#types").TypeFromFields<{
-                    current: import("#types").FieldType<PowerSource.BatFault[]>;
-                    previous: import("#types").FieldType<PowerSource.BatFault[]>;
-                }>, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly replaceable: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly batReplacementDescription: import("#types").FixedAttribute<string, any>;
-                readonly batCommonDesignation: import("#types").OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
-                readonly batAnsiDesignation: import("#types").OptionalFixedAttribute<string, any>;
-                readonly batIecDesignation: import("#types").OptionalFixedAttribute<string, any>;
-                readonly batApprovedChemistry: import("#types").OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
-                readonly batQuantity: import("#types").FixedAttribute<number, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly replaceable: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly batCapacity: import("#types").OptionalFixedAttribute<number, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly rechargeable: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly batCapacity: import("#types").OptionalFixedAttribute<number, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly rechargeable: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly batChargeState: import("#types").Attribute<PowerSource.BatChargeState, any>;
-                readonly batTimeToFullCharge: import("#types").OptionalAttribute<number | null, any>;
-                readonly batFunctionalWhileCharging: import("#types").Attribute<boolean, any>;
-                readonly batChargingCurrent: import("#types").OptionalAttribute<number | null, any>;
-                readonly activeBatChargeFaults: import("#types").OptionalAttribute<PowerSource.BatChargeFault[], any>;
-            };
-            readonly events: {
-                readonly batChargeFaultChange: import("#types").OptionalEvent<import("#types").TypeFromFields<{
-                    current: import("#types").FieldType<PowerSource.BatChargeFault[]>;
-                    previous: import("#types").FieldType<PowerSource.BatChargeFault[]>;
-                }>, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly rechargeable: true;
-            readonly battery: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly replaceable: true;
-            readonly battery: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly wired: true;
-            readonly battery: true;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly wired: false;
-            readonly battery: false;
-        };
-        readonly component: false;
-    }];
-}>, typeof import("../../index.js").ClusterBehavior, {
-    components: never[];
-}>, {
+}>, readonly [PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable]>, import("./PowerSourceBehavior.js").PowerSourceBehaviorConstructor, {
     components: never[];
 }>;
 /**

package/dist/cjs/behaviors/power-source/PowerSourceServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PowerSourceServer.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source/PowerSourceServer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAGrC,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0F,CAAC;AAErH;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,oBAAoB;IAC5C,UAAU;CAc5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAID,qBAAa,iBAAkB,SAAQ,sBAAwD;CAAG"}
+{"version":3,"file":"PowerSourceServer.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source/PowerSourceServer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAGrC,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0F,CAAC;AAErH;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,oBAAoB;IAC5C,UAAU;CAc5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAID,qBAAa,iBAAkB,SAAQ,sBAAwD;CAAG"}

package/dist/cjs/behaviors/power-source/index.d.ts

@@ -6,4 +6,5 @@
 /*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
 export * from "./PowerSourceBehavior.js";
 export * from "./PowerSourceServer.js";
+export * from "./PowerSourceClient.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/behaviors/power-source/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yEAAyE;AAEzE,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yEAAyE;AAEzE,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}

package/dist/cjs/behaviors/power-source/index.js

@@ -17,6 +17,7 @@ var power_source_exports = {};
 module.exports = __toCommonJS(power_source_exports);
 __reExport(power_source_exports, require("./PowerSourceBehavior.js"), module.exports);
 __reExport(power_source_exports, require("./PowerSourceServer.js"), module.exports);
+__reExport(power_source_exports, require("./PowerSourceClient.js"), module.exports);
 /**
  * @license
  * Copyright 2022-2025 Matter.js Authors

package/dist/cjs/behaviors/power-source/index.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/behaviors/power-source/index.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAQA,iCAAc,qCARd;AASA,iCAAc,mCATd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAQA,iCAAc,qCARd;AASA,iCAAc,mCATd;AAUA,iCAAc,mCAVd;AAAA;AAAA;AAAA;AAAA;AAAA;",
   "names": []
 }

package/dist/cjs/behaviors/power-source-configuration/PowerSourceConfigurationBehavior.d.ts

@@ -6,20 +6,21 @@
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 import { PowerSourceConfiguration } from "#clusters/power-source-configuration";
 import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { Identity } from "#general";
 /**
  * PowerSourceConfigurationBehavior is the base class for objects that support interaction with
  * {@link PowerSourceConfiguration.Cluster}.
  */
-export declare const PowerSourceConfigurationBehavior: ClusterBehavior.Type<PowerSourceConfiguration.Cluster, typeof ClusterBehavior, {
+export declare const PowerSourceConfigurationBehaviorConstructor: ClusterBehavior.Type<PowerSourceConfiguration.Cluster, typeof ClusterBehavior, {
     components: never[];
 }>;
-type PowerSourceConfigurationBehaviorType = InstanceType<typeof PowerSourceConfigurationBehavior>;
-export interface PowerSourceConfigurationBehavior extends PowerSourceConfigurationBehaviorType {
+export interface PowerSourceConfigurationBehaviorConstructor extends Identity<typeof PowerSourceConfigurationBehaviorConstructor> {
+}
+export declare const PowerSourceConfigurationBehavior: PowerSourceConfigurationBehaviorConstructor;
+export interface PowerSourceConfigurationBehavior extends InstanceType<PowerSourceConfigurationBehaviorConstructor> {
 }
-type StateType = InstanceType<typeof PowerSourceConfigurationBehavior.State>;
 export declare namespace PowerSourceConfigurationBehavior {
-    interface State extends StateType {
+    interface State extends InstanceType<typeof PowerSourceConfigurationBehavior.State> {
     }
 }
-export {};
 //# sourceMappingURL=PowerSourceConfigurationBehavior.d.ts.map

package/dist/cjs/behaviors/power-source-configuration/PowerSourceConfigurationBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PowerSourceConfigurationBehavior.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source-configuration/PowerSourceConfigurationBehavior.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,gCAAgC;;EAAwD,CAAC;AAEtG,KAAK,oCAAoC,GAAG,YAAY,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAClG,MAAM,WAAW,gCAAiC,SAAQ,oCAAoC;CAAG;AACjG,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,gCAAgC,CAAC,KAAK,CAAC,CAAC;AAC7E,yBAAiB,gCAAgC,CAAC;IAAE,UAAiB,KAAM,SAAQ,SAAS;KAAG;CAAE"}
+{"version":3,"file":"PowerSourceConfigurationBehavior.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source-configuration/PowerSourceConfigurationBehavior.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,2CAA2C;;EAAwD,CAAC;AAEjH,MAAM,WAAW,2CAA4C,SAAQ,QAAQ,CAAC,OAAO,2CAA2C,CAAC;CAAG;AACpI,eAAO,MAAM,gCAAgC,EAAE,2CAAyF,CAAC;AACzI,MAAM,WAAW,gCAAiC,SAAQ,YAAY,CAAC,2CAA2C,CAAC;CAAG;AACtH,yBAAiB,gCAAgC,CAAC;IAC9C,UAAiB,KAAM,SAAQ,YAAY,CAAC,OAAO,gCAAgC,CAAC,KAAK,CAAC;KAAG;CAChG"}

package/dist/cjs/behaviors/power-source-configuration/PowerSourceConfigurationBehavior.js

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var PowerSourceConfigurationBehavior_exports = {};
 __export(PowerSourceConfigurationBehavior_exports, {
-  PowerSourceConfigurationBehavior: () => PowerSourceConfigurationBehavior
+  PowerSourceConfigurationBehavior: () => PowerSourceConfigurationBehavior,
+  PowerSourceConfigurationBehaviorConstructor: () => PowerSourceConfigurationBehaviorConstructor
 });
 module.exports = __toCommonJS(PowerSourceConfigurationBehavior_exports);
 var import_power_source_configuration = require("#clusters/power-source-configuration");
@@ -28,5 +29,6 @@ var import_ClusterBehavior = require("../../behavior/cluster/ClusterBehavior.js"
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-const PowerSourceConfigurationBehavior = import_ClusterBehavior.ClusterBehavior.for(import_power_source_configuration.PowerSourceConfiguration.Cluster);
+const PowerSourceConfigurationBehaviorConstructor = import_ClusterBehavior.ClusterBehavior.for(import_power_source_configuration.PowerSourceConfiguration.Cluster);
+const PowerSourceConfigurationBehavior = PowerSourceConfigurationBehaviorConstructor;
 //# sourceMappingURL=PowerSourceConfigurationBehavior.js.map

package/dist/cjs/behaviors/power-source-configuration/PowerSourceConfigurationBehavior.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/behaviors/power-source-configuration/PowerSourceConfigurationBehavior.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,wCAAyC;AACzC,6BAAgC;AAThC;AAAA;AAAA;AAAA;AAAA;AAeO,MAAM,mCAAmC,uCAAgB,IAAI,2DAAyB,OAAO;",
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,wCAAyC;AACzC,6BAAgC;AAThC;AAAA;AAAA;AAAA;AAAA;AAgBO,MAAM,8CAA8C,uCAAgB,IAAI,2DAAyB,OAAO;AAGxG,MAAM,mCAAgF;",
   "names": []
 }

package/dist/cjs/behaviors/power-source-configuration/PowerSourceConfigurationClient.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+import { PowerSourceConfigurationBehavior } from "./PowerSourceConfigurationBehavior.js";
+import { Identity } from "#general";
+export declare const PowerSourceConfigurationClientConstructor: import("./PowerSourceConfigurationBehavior.js").PowerSourceConfigurationBehaviorConstructor;
+export interface PowerSourceConfigurationClient extends PowerSourceConfigurationBehavior {
+}
+export interface PowerSourceConfigurationClientConstructor extends Identity<typeof PowerSourceConfigurationClientConstructor> {
+}
+export declare const PowerSourceConfigurationClient: PowerSourceConfigurationClientConstructor;
+//# sourceMappingURL=PowerSourceConfigurationClient.d.ts.map

package/dist/cjs/behaviors/power-source-configuration/PowerSourceConfigurationClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PowerSourceConfigurationClient.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source-configuration/PowerSourceConfigurationClient.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,gCAAgC,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,eAAO,MAAM,yCAAyC,6FAAmC,CAAC;AAC1F,MAAM,WAAW,8BAA+B,SAAQ,gCAAgC;CAAG;AAC3F,MAAM,WAAW,yCAA0C,SAAQ,QAAQ,CAAC,OAAO,yCAAyC,CAAC;CAAG;AAChI,eAAO,MAAM,8BAA8B,EAAE,yCAAqF,CAAC"}

package/dist/cjs/behaviors/power-source-configuration/PowerSourceConfigurationClient.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PowerSourceConfigurationClient_exports = {};
+__export(PowerSourceConfigurationClient_exports, {
+  PowerSourceConfigurationClient: () => PowerSourceConfigurationClient,
+  PowerSourceConfigurationClientConstructor: () => PowerSourceConfigurationClientConstructor
+});
+module.exports = __toCommonJS(PowerSourceConfigurationClient_exports);
+var import_PowerSourceConfigurationBehavior = require("./PowerSourceConfigurationBehavior.js");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const PowerSourceConfigurationClientConstructor = import_PowerSourceConfigurationBehavior.PowerSourceConfigurationBehavior;
+const PowerSourceConfigurationClient = PowerSourceConfigurationClientConstructor;
+//# sourceMappingURL=PowerSourceConfigurationClient.js.map

package/dist/cjs/behaviors/power-source-configuration/PowerSourceConfigurationClient.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/behaviors/power-source-configuration/PowerSourceConfigurationClient.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,8CAAiD;AARjD;AAAA;AAAA;AAAA;AAAA;AAWO,MAAM,4CAA4C;AAGlD,MAAM,iCAA4E;",
+  "names": []
+}

package/dist/cjs/behaviors/power-source-configuration/index.d.ts

@@ -6,4 +6,5 @@
 /*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
 export * from "./PowerSourceConfigurationBehavior.js";
 export * from "./PowerSourceConfigurationServer.js";
+export * from "./PowerSourceConfigurationClient.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/behaviors/power-source-configuration/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source-configuration/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yEAAyE;AAEzE,cAAc,uCAAuC,CAAC;AACtD,cAAc,qCAAqC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-source-configuration/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yEAAyE;AAEzE,cAAc,uCAAuC,CAAC;AACtD,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC"}

package/dist/cjs/behaviors/power-source-configuration/index.js

@@ -17,6 +17,7 @@ var power_source_configuration_exports = {};
 module.exports = __toCommonJS(power_source_configuration_exports);
 __reExport(power_source_configuration_exports, require("./PowerSourceConfigurationBehavior.js"), module.exports);
 __reExport(power_source_configuration_exports, require("./PowerSourceConfigurationServer.js"), module.exports);
+__reExport(power_source_configuration_exports, require("./PowerSourceConfigurationClient.js"), module.exports);
 /**
  * @license
  * Copyright 2022-2025 Matter.js Authors

package/dist/cjs/behaviors/power-source-configuration/index.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/behaviors/power-source-configuration/index.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAQA,+CAAc,kDARd;AASA,+CAAc,gDATd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAQA,+CAAc,kDARd;AASA,+CAAc,gDATd;AAUA,+CAAc,gDAVd;AAAA;AAAA;AAAA;AAAA;AAAA;",
   "names": []
 }

package/dist/cjs/behaviors/power-topology/PowerTopologyBehavior.d.ts

@@ -5,13 +5,14 @@
  */
 import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
 import { ClusterType } from "#types";
+import { Identity } from "#general";
 /**
  * PowerTopologyBehavior is the base class for objects that support interaction with {@link PowerTopology.Cluster}.
  *
  * PowerTopology.Cluster requires you to enable one or more optional features. You can do so using
  * {@link PowerTopologyBehavior.with}.
  */
-export declare const PowerTopologyBehavior: ClusterBehavior.Type<ClusterType.Of<{
+export declare const PowerTopologyBehaviorConstructor: ClusterBehavior.Type<ClusterType.Of<{
     readonly id: 156;
     readonly name: "PowerTopology";
     readonly revision: 1;
@@ -74,13 +75,13 @@ export declare const PowerTopologyBehavior: ClusterBehavior.Type<ClusterType.Of<
 }>, typeof ClusterBehavior, {
     components: never[];
 }>;
-type PowerTopologyBehaviorType = InstanceType<typeof PowerTopologyBehavior>;
-export interface PowerTopologyBehavior extends PowerTopologyBehaviorType {
+export interface PowerTopologyBehaviorConstructor extends Identity<typeof PowerTopologyBehaviorConstructor> {
+}
+export declare const PowerTopologyBehavior: PowerTopologyBehaviorConstructor;
+export interface PowerTopologyBehavior extends InstanceType<PowerTopologyBehaviorConstructor> {
 }
-type StateType = InstanceType<typeof PowerTopologyBehavior.State>;
 export declare namespace PowerTopologyBehavior {
-    interface State extends StateType {
+    interface State extends InstanceType<typeof PowerTopologyBehavior.State> {
     }
 }
-export {};
 //# sourceMappingURL=PowerTopologyBehavior.d.ts.map

package/dist/cjs/behaviors/power-topology/PowerTopologyBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PowerTopologyBehavior.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-topology/PowerTopologyBehavior.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAuD,CAAC;AAE1F,KAAK,yBAAyB,GAAG,YAAY,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC5E,MAAM,WAAW,qBAAsB,SAAQ,yBAAyB;CAAG;AAC3E,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,qBAAqB,CAAC,KAAK,CAAC,CAAC;AAClE,yBAAiB,qBAAqB,CAAC;IAAE,UAAiB,KAAM,SAAQ,SAAS;KAAG;CAAE"}
+{"version":3,"file":"PowerTopologyBehavior.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/power-topology/PowerTopologyBehavior.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAuD,CAAC;AAErG,MAAM,WAAW,gCAAiC,SAAQ,QAAQ,CAAC,OAAO,gCAAgC,CAAC;CAAG;AAC9G,eAAO,MAAM,qBAAqB,EAAE,gCAAmE,CAAC;AACxG,MAAM,WAAW,qBAAsB,SAAQ,YAAY,CAAC,gCAAgC,CAAC;CAAG;AAChG,yBAAiB,qBAAqB,CAAC;IACnC,UAAiB,KAAM,SAAQ,YAAY,CAAC,OAAO,qBAAqB,CAAC,KAAK,CAAC;KAAG;CACrF"}