matterbridge 1.3.1 → 1.3.3

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.3.3] - 2024-06-22
+
+### Changed
+- [matterbridge]: Updated dependencies
+- [matterbridge]: When a plugin is in an error state, the bridge does not start to avoid causing the controllers to delete the registered devices and lose the configuration (e.g. room and automations).
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="./yellow-button.png" alt="Buy me a coffee" width="120">
+</a>
+
+## [1.3.2] - 2024-06-22
+
+New plugin
+
+[shelly](https://github.com/Luligu/matterbridge-shelly)
+
+Matterbridge shelly allows you to expose Shelly Gen 1, Gen 2, and Gen 3 devices to Matter.
+
+Features:
+
+- Shellies are automatically discovered using mDNS.
+- Discovered shellies are stored in local storage for quick loading on startup.
+- In this first release, the components exposed are lights (with brightness), switches, rollers and power meters (with EveHistory electrical measurements).
+- Shellies are controlled locally, eliminating the need for cloud or MQTT (which can be disabled).
+- Shelly Gen 1 devices are controlled using the CoIoT protocol (see the note below).
+- Shelly Gen 2 and Gen 3 devices are controlled using WebSocket.
+- The Matter device takes the name configured in the Shelly device's web page.
+- A 10-minute timer checks if the device has reported in that time.
+
+### Added
+- [matterbridgeDevice]: Added all clusters for airQualitySensor:
+    CarbonMonoxideConcentrationMeasurement,
+    CarbonDioxideConcentrationMeasurement,
+    NitrogenDioxideConcentrationMeasurement,
+    OzoneConcentrationMeasurement,
+    FormaldehydeConcentrationMeasurement,
+    Pm1ConcentrationMeasurement,
+    Pm25ConcentrationMeasurement,
+    Pm10ConcentrationMeasurement,
+    RadonConcentrationMeasurement,
+
+### Changed
+- [matterbridge]: Updated dependencies
+- [matter.js]: Updated matter.js to 0.9.2
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="./yellow-button.png" alt="Buy me a coffee" width="120">
+</a>
+
 ## [1.3.1] - 2024-06-20
 
 ### Changed

package/CODEOWNERS

@@ -0,0 +1 @@
+@Luligu

package/README.md

@@ -113,6 +113,33 @@ Config editor:
 
 ## Plugins
 
+### Production-level plugins
+
+[zigbee2mqtt](https://github.com/Luligu/matterbridge-zigbee2mqtt)
+
+Matterbridge zigbee2mqtt is a matterbridge production-level plugin that expose all zigbee2mqtt devices and groups to Matter.
+
+No hub or dedicated hardware needed.
+
+[somy-tahoma](https://github.com/Luligu/matterbridge-somfy-tahoma)
+
+Matterbridge Somfy Tahoma is a matterbridge production-level plugin that expose all Somfy Tahoma devices to Matter.
+
+[shelly](https://github.com/Luligu/matterbridge-shelly)
+
+Matterbridge shelly allows you to expose Shelly Gen 1, Gen 2, and Gen 3 devices to Matter.
+
+Features:
+
+- Shellies are automatically discovered using mDNS.
+- Discovered shellies are stored in local storage for quick loading on startup.
+- In this first release, the components exposed are lights (with brightness), switches, rollers and meters.
+- Shellies are controlled locally, eliminating the need for cloud or MQTT (which can be disabled).
+- Shelly Gen 1 devices are controlled using the CoIoT protocol (see the note below).
+- Shelly Gen 2 and Gen 3 devices are controlled using WebSocket.
+- The Matter device takes the name configured in the Shelly device's web page.
+- A 10-minute timer checks if the device has reported in that time.
+
 ### Accessory platform example
 
 This an example of an accessory platform plugin. 
@@ -153,17 +180,6 @@ The history works in both bridge and childbridge mode.
 
 The Eve app only shows the history when the plugins run like an AccessoryPlatform in childbridge mode (this means the plugin is paired directly).
 
-### Production-level plugins
-
-[zigbee2mqtt](https://github.com/Luligu/matterbridge-zigbee2mqtt)
-
-Matterbridge zigbee2mqtt is a matterbridge production-level plugin that expose all zigbee2mqtt devices and groups to Matter.
-
-No hub or dedicated hardware needed.
-
-[somy-tahoma](https://github.com/Luligu/matterbridge-somfy-tahoma)
-
-Matterbridge Somfy Tahoma is a matterbridge production-level plugin that expose all Somfy Tahoma devices to Matter.
 
 ## How to install and register a production-level plugin (from npm)
 

package/dist/cluster/CarbonDioxideConcentrationMeasurementCluster.d.ts

@@ -0,0 +1,396 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** * THIS FILE IS GENERATED, DO NOT EDIT ***/
+import { MutableCluster } from '@project-chip/matter-node.js/cluster';
+import { Identity } from '@project-chip/matter-node.js/util';
+import { ConcentrationMeasurement } from './ConcentrationMeasurementCluster.js';
+export declare namespace CarbonDioxideConcentrationMeasurement {
+    const Base: {
+        id: number;
+        name: string;
+        features: {
+            readonly numericMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+            readonly levelIndication: import("@project-chip/matter.js/schema").BitFlag;
+            readonly mediumLevel: import("@project-chip/matter.js/schema").BitFlag;
+            readonly criticalLevel: import("@project-chip/matter.js/schema").BitFlag;
+            readonly peakMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+            readonly averageMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+        };
+        revision: 3;
+        attributes: {
+            readonly measurementMedium: import("@project-chip/matter-node.js/cluster").FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
+        };
+        extensions: readonly [{
+            readonly flags: {
+                readonly numericMeasurement: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly measuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly minMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly maxMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly uncertainty: import("@project-chip/matter-node.js/cluster").OptionalAttribute<number, any>;
+                    readonly measurementUnit: import("@project-chip/matter-node.js/cluster").FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly peakMeasurement: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly peakMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly peakMeasuredValueWindow: import("@project-chip/matter-node.js/cluster").Attribute<number, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly averageMeasurement: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly averageMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly averageMeasuredValueWindow: import("@project-chip/matter-node.js/cluster").Attribute<number, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly levelIndication: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly levelValue: import("@project-chip/matter-node.js/cluster").Attribute<ConcentrationMeasurement.LevelValue, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly mediumLevel: true;
+                readonly levelIndication: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly criticalLevel: true;
+                readonly levelIndication: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly peakMeasurement: true;
+                readonly numericMeasurement: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly averageMeasurement: true;
+                readonly numericMeasurement: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly numericMeasurement: false;
+                readonly levelIndication: false;
+            };
+            readonly component: false;
+        }];
+    };
+    /**
+     * @see {@link Cluster}
+     */
+    const ClusterInstance: MutableCluster.ExtensibleOnly<{
+        id: number;
+        name: string;
+        features: {
+            readonly numericMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+            readonly levelIndication: import("@project-chip/matter.js/schema").BitFlag;
+            readonly mediumLevel: import("@project-chip/matter.js/schema").BitFlag;
+            readonly criticalLevel: import("@project-chip/matter.js/schema").BitFlag;
+            readonly peakMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+            readonly averageMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+        };
+        revision: 3;
+        attributes: {
+            readonly measurementMedium: import("@project-chip/matter-node.js/cluster").FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
+        };
+        extensions: readonly [{
+            readonly flags: {
+                readonly numericMeasurement: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly measuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly minMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly maxMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly uncertainty: import("@project-chip/matter-node.js/cluster").OptionalAttribute<number, any>;
+                    readonly measurementUnit: import("@project-chip/matter-node.js/cluster").FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly peakMeasurement: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly peakMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly peakMeasuredValueWindow: import("@project-chip/matter-node.js/cluster").Attribute<number, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly averageMeasurement: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly averageMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                    readonly averageMeasuredValueWindow: import("@project-chip/matter-node.js/cluster").Attribute<number, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly levelIndication: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly levelValue: import("@project-chip/matter-node.js/cluster").Attribute<ConcentrationMeasurement.LevelValue, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly mediumLevel: true;
+                readonly levelIndication: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly criticalLevel: true;
+                readonly levelIndication: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly peakMeasurement: true;
+                readonly numericMeasurement: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly averageMeasurement: true;
+                readonly numericMeasurement: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly numericMeasurement: false;
+                readonly levelIndication: false;
+            };
+            readonly component: false;
+        }];
+    }>;
+    /**
+     * This alias specializes the semantics of {@link ConcentrationMeasurement.Cluster}.
+     *
+     * Per the Matter specification you cannot use {@link CarbonDioxideConcentrationMeasurementCluster} without
+     * enabling certain feature combinations. You must use the {@link with} factory method to obtain a working cluster.
+     */
+    type Cluster = Identity<typeof ClusterInstance>;
+    const Cluster: Cluster;
+    /**
+     * This cluster supports all CarbonDioxideConcentrationMeasurement features. It may support illegal feature
+     * combinations.
+     *
+     * If you use this cluster you must manually specify which features are active and ensure the set of active
+     * features is legal per the Matter specification.
+     */
+    const CompleteInstance: MutableCluster<{
+        readonly id: 1037;
+        readonly name: "ConcentrationMeasurement";
+        readonly revision: 3;
+        readonly features: {
+            readonly numericMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+            readonly levelIndication: import("@project-chip/matter.js/schema").BitFlag;
+            readonly mediumLevel: import("@project-chip/matter.js/schema").BitFlag;
+            readonly criticalLevel: import("@project-chip/matter.js/schema").BitFlag;
+            readonly peakMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+            readonly averageMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+        };
+        readonly attributes: {
+            readonly measuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    numericMeasurement: boolean;
+                }];
+            };
+            readonly minMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    numericMeasurement: boolean;
+                }];
+            };
+            readonly maxMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    numericMeasurement: boolean;
+                }];
+            };
+            readonly peakMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    peakMeasurement: boolean;
+                }];
+            };
+            readonly peakMeasuredValueWindow: import("@project-chip/matter-node.js/cluster").Attribute<number, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    peakMeasurement: boolean;
+                }];
+            };
+            readonly averageMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    averageMeasurement: boolean;
+                }];
+            };
+            readonly averageMeasuredValueWindow: import("@project-chip/matter-node.js/cluster").Attribute<number, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    averageMeasurement: boolean;
+                }];
+            };
+            readonly uncertainty: import("@project-chip/matter-node.js/cluster").OptionalAttribute<number, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: [] | [{
+                    numericMeasurement: boolean;
+                }];
+                readonly mandatoryIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+            };
+            readonly measurementUnit: import("@project-chip/matter-node.js/cluster").FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    numericMeasurement: boolean;
+                }];
+            };
+            readonly levelValue: import("@project-chip/matter-node.js/cluster").Attribute<ConcentrationMeasurement.LevelValue, any> & {
+                readonly optional: true;
+                readonly isConditional: true;
+                readonly optionalIf: import("@project-chip/matter-node.js/cluster").ConditionalFeatureList<import("@project-chip/matter.js/schema").BitSchema> | [];
+                readonly mandatoryIf: [] | [{
+                    levelIndication: boolean;
+                }];
+            };
+            readonly measurementMedium: import("@project-chip/matter-node.js/cluster").FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
+        };
+    }>;
+    type Complete = Identity<typeof CompleteInstance>;
+    const Complete: Complete;
+}
+export type CarbonDioxideConcentrationMeasurementCluster = CarbonDioxideConcentrationMeasurement.Cluster;
+export declare const CarbonDioxideConcentrationMeasurementCluster: MutableCluster.ExtensibleOnly<{
+    id: number;
+    name: string;
+    features: {
+        readonly numericMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+        readonly levelIndication: import("@project-chip/matter.js/schema").BitFlag;
+        readonly mediumLevel: import("@project-chip/matter.js/schema").BitFlag;
+        readonly criticalLevel: import("@project-chip/matter.js/schema").BitFlag;
+        readonly peakMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+        readonly averageMeasurement: import("@project-chip/matter.js/schema").BitFlag;
+    };
+    revision: 3;
+    attributes: {
+        readonly measurementMedium: import("@project-chip/matter-node.js/cluster").FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
+    };
+    extensions: readonly [{
+        readonly flags: {
+            readonly numericMeasurement: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly measuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                readonly minMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                readonly maxMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                readonly uncertainty: import("@project-chip/matter-node.js/cluster").OptionalAttribute<number, any>;
+                readonly measurementUnit: import("@project-chip/matter-node.js/cluster").FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly peakMeasurement: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly peakMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                readonly peakMeasuredValueWindow: import("@project-chip/matter-node.js/cluster").Attribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly averageMeasurement: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly averageMeasuredValue: import("@project-chip/matter-node.js/cluster").Attribute<number | null, any>;
+                readonly averageMeasuredValueWindow: import("@project-chip/matter-node.js/cluster").Attribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly levelIndication: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly levelValue: import("@project-chip/matter-node.js/cluster").Attribute<ConcentrationMeasurement.LevelValue, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly mediumLevel: true;
+            readonly levelIndication: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly criticalLevel: true;
+            readonly levelIndication: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly peakMeasurement: true;
+            readonly numericMeasurement: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly averageMeasurement: true;
+            readonly numericMeasurement: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly numericMeasurement: false;
+            readonly levelIndication: false;
+        };
+        readonly component: false;
+    }];
+}>;
+//# sourceMappingURL=CarbonDioxideConcentrationMeasurementCluster.d.ts.map

package/dist/cluster/CarbonDioxideConcentrationMeasurementCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CarbonDioxideConcentrationMeasurementCluster.d.ts","sourceRoot":"","sources":["../../src/cluster/CarbonDioxideConcentrationMeasurementCluster.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAEH,8CAA8C;AAE9C,OAAO,EAAmB,cAAc,EAAE,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAC7D,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAEhF,yBAAiB,qCAAqC,CAAC;IAC9C,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAiG,CAAC;IAEnH;;OAEG;IACI,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAsC,CAAC;IAEnE;;;;;OAKG;IACH,KAAY,OAAO,GAAG,QAAQ,CAAC,OAAO,eAAe,CAAC,CAAC;IAEhD,MAAM,OAAO,EAAE,OAAyB,CAAC;IAEhD;;;;;;OAMG;IACI,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAsE,CAAC;IAEpG,KAAY,QAAQ,GAAG,QAAQ,CAAC,OAAO,gBAAgB,CAAC,CAAC;IAClD,MAAM,QAAQ,EAAE,QAA2B,CAAC;CACpD;AAED,MAAM,MAAM,4CAA4C,GAAG,qCAAqC,CAAC,OAAO,CAAC;AACzG,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgD,CAAC"}

package/dist/cluster/CarbonDioxideConcentrationMeasurementCluster.js

@@ -0,0 +1,30 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** * THIS FILE IS GENERATED, DO NOT EDIT ***/
+import { ClusterRegistry, MutableCluster } from '@project-chip/matter-node.js/cluster';
+import { ConcentrationMeasurement } from './ConcentrationMeasurementCluster.js';
+export var CarbonDioxideConcentrationMeasurement;
+(function (CarbonDioxideConcentrationMeasurement) {
+    CarbonDioxideConcentrationMeasurement.Base = { ...ConcentrationMeasurement.Base, id: 0x40d, name: 'CarbonDioxideConcentrationMeasurement' };
+    /**
+     * @see {@link Cluster}
+     */
+    CarbonDioxideConcentrationMeasurement.ClusterInstance = MutableCluster.ExtensibleOnly(CarbonDioxideConcentrationMeasurement.Base);
+    CarbonDioxideConcentrationMeasurement.Cluster = CarbonDioxideConcentrationMeasurement.ClusterInstance;
+    /**
+     * This cluster supports all CarbonDioxideConcentrationMeasurement features. It may support illegal feature
+     * combinations.
+     *
+     * If you use this cluster you must manually specify which features are active and ensure the set of active
+     * features is legal per the Matter specification.
+     */
+    CarbonDioxideConcentrationMeasurement.CompleteInstance = MutableCluster({ ...ConcentrationMeasurement.Complete, id: 0x40d });
+    CarbonDioxideConcentrationMeasurement.Complete = CarbonDioxideConcentrationMeasurement.CompleteInstance;
+})(CarbonDioxideConcentrationMeasurement || (CarbonDioxideConcentrationMeasurement = {}));
+export const CarbonDioxideConcentrationMeasurementCluster = CarbonDioxideConcentrationMeasurement.Cluster;
+ClusterRegistry.register(CarbonDioxideConcentrationMeasurement.Complete);
+//# sourceMappingURL=CarbonDioxideConcentrationMeasurementCluster.js.map

package/dist/cluster/CarbonDioxideConcentrationMeasurementCluster.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CarbonDioxideConcentrationMeasurementCluster.js","sourceRoot":"","sources":["../../src/cluster/CarbonDioxideConcentrationMeasurementCluster.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD;;;;GAIG;AAEH,8CAA8C;AAE9C,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAEvF,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAEhF,MAAM,KAAW,qCAAqC,CA6BrD;AA7BD,WAAiB,qCAAqC;IACvC,0CAAI,GAAG,EAAE,GAAG,wBAAwB,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,uCAAuC,EAAE,CAAC;IAEnH;;OAEG;IACU,qDAAe,GAAG,cAAc,CAAC,cAAc,CAAC,sCAAA,IAAI,CAAC,CAAC;IAUtD,6CAAO,GAAY,sCAAA,eAAe,CAAC;IAEhD;;;;;;OAMG;IACU,sDAAgB,GAAG,cAAc,CAAC,EAAE,GAAG,wBAAwB,CAAC,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAGvF,8CAAQ,GAAa,sCAAA,gBAAgB,CAAC;AACrD,CAAC,EA7BgB,qCAAqC,KAArC,qCAAqC,QA6BrD;AAGD,MAAM,CAAC,MAAM,4CAA4C,GAAG,qCAAqC,CAAC,OAAO,CAAC;AAC1G,eAAe,CAAC,QAAQ,CAAC,qCAAqC,CAAC,QAAQ,CAAC,CAAC"}