@matter/types 0.11.0-alpha.0-20241005-e3e4e4a7a

package/src/clusters/oven-cavity-operational-state.ts

@@ -0,0 +1,292 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MutableCluster } from "../cluster/mutation/MutableCluster.js";
+import {
+    Attribute,
+    OptionalAttribute,
+    OptionalCommand,
+    TlvNoResponse,
+    Event,
+    EventPriority,
+    OptionalEvent
+} from "../cluster/Cluster.js";
+import { TlvArray } from "../tlv/TlvArray.js";
+import { TlvString } from "../tlv/TlvString.js";
+import { TlvNullable } from "../tlv/TlvNullable.js";
+import { TlvUInt8, TlvUInt32 } from "../tlv/TlvNumber.js";
+import { OperationalState } from "./operational-state.js";
+import { TlvNoArguments } from "../tlv/TlvNoArguments.js";
+import { Identity } from "#general";
+import { ClusterRegistry } from "../cluster/ClusterRegistry.js";
+
+export namespace OvenCavityOperationalState {
+    /**
+     * @see {@link Cluster}
+     */
+    export const ClusterInstance = MutableCluster({
+        id: 0x48,
+        name: "OvenCavityOperationalState",
+        revision: 1,
+
+        attributes: {
+            /**
+             * Indicates a list of names of different phases that the device can go through for the selected function
+             * or mode. The list may not be in sequence order. For example in a washing machine this could include
+             * items such as "pre-soak", "rinse", and "spin". These phases are manufacturer specific and may change
+             * when a different function or mode is selected.
+             *
+             * A null value indicates that the device does not present phases during its operation. When this
+             * attribute’s value is null, the CurrentPhase attribute shall also be set to null.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.5.1
+             */
+            phaseList: Attribute(0x0, TlvNullable(TlvArray(TlvString, { maxLength: 32 }))),
+
+            /**
+             * This attribute represents the current phase of operation being performed by the server. This shall be
+             * the positional index representing the value from the set provided in the PhaseList Attribute, where the
+             * first item in that list is an index of 0. Thus, this attribute shall have a maximum value that is
+             * "length(PhaseList) - 1".
+             *
+             * Null if the PhaseList attribute is null or if the PhaseList attribute is an empty list.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.5.2
+             */
+            currentPhase: Attribute(0x1, TlvNullable(TlvUInt8)),
+
+            /**
+             * Indicates the estimated time left before the operation is completed, in seconds. Changes to this value
+             * shall NOT be reported in a subscription (note the C Quality). A Client implementation may periodically
+             * poll this value to ensure alignment of any local rendering of the CountdownTime with the device provided
+             * value.
+             *
+             * A value of 0 means that the operation has completed.
+             *
+             * When this attribute is null, that represents that there is no time currently defined until operation
+             * completion. This may happen, for example, because no operation is in progress or because the completion
+             * time is unknown.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.5.3
+             */
+            countdownTime: OptionalAttribute(
+                0x2,
+                TlvNullable(TlvUInt32.bound({ max: 259200 })),
+                { omitChanges: true, default: null }
+            ),
+
+            /**
+             * This attribute describes the set of possible operational states that the device exposes. An operational
+             * state is a fundamental device state such as Running or Error. Details of the phase of a device when, for
+             * example, in a state of Running are provided by the CurrentPhase attribute.
+             *
+             * All devices shall, at a minimum, expose the set of states matching the commands that are also supported
+             * by the cluster instance, in addition to Error. The set of possible device states are defined in the
+             * OperationalStateEnum. A device type requiring implementation of this cluster shall define the set of
+             * states that are applicable to that specific device type.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.5.4
+             */
+            operationalStateList: Attribute(0x3, TlvArray(OperationalState.TlvOperationalStateStruct), { default: [] }),
+
+            /**
+             * This attribute specifies the current operational state of a device. This shall be populated with a valid
+             * OperationalStateID from the set of values in the OperationalStateList Attribute.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.5.5
+             */
+            operationalState: Attribute(0x4, TlvUInt8),
+
+            /**
+             * This attribute shall specify the details of any current error condition being experienced on the device
+             * when the OperationalState attribute is populated with Error. Please see ErrorStateStruct for general
+             * requirements on the population of this attribute.
+             *
+             * When there is no error detected, this shall have an ErrorStateID of NoError.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.5.6
+             */
+            operationalError: Attribute(0x5, OperationalState.TlvErrorState)
+        },
+
+        commands: {
+            /**
+             * This command shall be supported if the device supports remotely pausing the operation. If this command
+             * is supported, the Resume command shall also be supported.
+             *
+             * On receipt of this command, the device shall pause its operation if it is possible based on the current
+             * function of the server. For example, if it is at a point where it is safe to do so and/or permitted, but
+             * can be restarted from the point at which pause occurred.
+             *
+             * If this command is received when already in the Paused state the device shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of NoError but take no further action.
+             *
+             * A device that receives this command in any state which is not Pause-compatible shall respond
+             *
+             * with an OperationalCommandResponse command with an ErrorStateID of CommandInvalidInState and shall take
+             * no further action.
+             *
+             * States are defined as Pause-compatible as follows:
+             *
+             *   • For states defined in this cluster specification, in Table 3, “Pause Compatibility”.
+             *
+             *   • For states defined by derived cluster specifications, in the corresponding specifications.
+             *
+             *   • For manufacturer-specific states, by the manufacturer.
+             *
+             * A device that is unable to honor the Pause command for whatever reason shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of CommandInvalidInState but take no further
+             * action.
+             *
+             * Otherwise, on success:
+             *
+             *   • The OperationalState attribute shall be set to Paused.
+             *
+             *   • The device shall respond with an OperationalCommandResponse command with an ErrorStateID of NoError.
+             *
+             * The following table defines the compatibility of this cluster’s states with the Pause command.
+             *
+             * ### Table 3. Pause Compatibility
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.6.1
+             */
+            pause: OptionalCommand(0x0, TlvNoArguments, 0x0, TlvNoResponse),
+
+            /**
+             * This command shall be supported if the device supports remotely stopping the operation.
+             *
+             * On receipt of this command, the device shall stop its operation if it is at a position where it is safe
+             * to do so and/or permitted. Restart of the device following the receipt of the Stop command shall require
+             * attended operation unless remote start is allowed by the device type and any jurisdiction governing
+             * remote operation of the device.
+             *
+             * If this command is received when already in the Stopped state the device shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of NoError but take no further action.
+             *
+             * A device that is unable to honor the Stop command for whatever reason shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of CommandInvalidInState but take no further
+             * action.
+             *
+             * Otherwise, on success:
+             *
+             *   • The OperationalState attribute shall be set to Stopped.
+             *
+             *   • The device shall respond with an OperationalCommandResponse command with an ErrorStateID of NoError.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.6.2
+             */
+            stop: OptionalCommand(0x1, TlvNoArguments, 0x1, TlvNoResponse),
+
+            /**
+             * This command shall be supported if the device supports remotely starting the operation. If this command
+             * is supported, the 'Stop command shall also be supported.
+             *
+             * On receipt of this command, the device shall start its operation if it is safe to do so and the device
+             * is in an operational state from which it can be started. There may be either regulatory or
+             * manufacturer-imposed safety and security requirements that first necessitate some specific action at the
+             * device before a Start command can be honored. In such instances, a device shall respond with a status
+             * code of CommandInvalidInState if a Start command is received prior to the required on- device action.
+             *
+             * If this command is received when already in the Running state the device shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of NoError but take no further action.
+             *
+             * A device that is unable to honor the Start command for whatever reason shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of UnableToStartOrResume but take no further
+             * action.
+             *
+             * Otherwise, on success:
+             *
+             *   • The OperationalState attribute shall be set to Running.
+             *
+             *   • The device shall respond with an OperationalCommandResponse command with an ErrorStateID of NoError.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.6.3
+             */
+            start: OptionalCommand(0x2, TlvNoArguments, 0x2, TlvNoResponse),
+
+            /**
+             * This command shall be supported if the device supports remotely resuming the operation. If this command
+             * is supported, the Pause command shall also be supported.
+             *
+             * On receipt of this command, the device shall resume its operation from the point it was at when it
+             * received the Pause command, or from the point when it was paused by means outside of this cluster (for
+             * example by manual button press).
+             *
+             * If this command is received when already in the Running state the device shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of NoError but take no further action.
+             *
+             * A device that receives this command in any state which is not Resume-compatible shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of CommandInvalidInState and shall take no
+             * further action.
+             *
+             * States are defined as Resume-compatible as follows:
+             *
+             *   • For states defined in this cluster specification, in Table 4, “Resume Compatibility”.
+             *
+             *   • For states defined by derived cluster specifications, in the corresponding specifications.
+             *
+             *   • For manufacturer-specific states, by the manufacturer.
+             *
+             * The following table defines the compatibility of this cluster’s states with the Resume command.
+             *
+             * ### Table 4. Resume Compatibility
+             *
+             * A device that is unable to honor the Resume command for any other reason shall respond with an
+             * OperationalCommandResponse command with an ErrorStateID of UnableToStartOrResume but take no further
+             * action.
+             *
+             * Otherwise, on success:
+             *
+             *   • The OperationalState attribute shall be set to the most recent non-Error operational state prior to
+             *     entering the Paused state.
+             *
+             *   • The device shall respond with an OperationalCommandResponse command with an ErrorStateID of NoError.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.6.4
+             */
+            resume: OptionalCommand(0x3, TlvNoArguments, 0x3, TlvNoResponse)
+        },
+
+        events: {
+            /**
+             * This event is generated when a reportable error condition is detected. A device that generates this
+             * event shall also set the OperationalState attribute to Error, indicating an error condition.
+             *
+             * This event shall contain the following fields:
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.7.1
+             */
+            operationalError: Event(0x0, EventPriority.Critical, OperationalState.TlvOperationalErrorEvent),
+
+            /**
+             * This event is generated when the overall operation ends, successfully or otherwise. For example, the
+             * completion of a cleaning operation in a Robot Vacuum Cleaner, or the completion of a wash cycle in a
+             * Washing Machine.
+             *
+             * This event shall contain the following fields:
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.14.7.2
+             */
+            operationCompletion: OptionalEvent(0x1, EventPriority.Info, OperationalState.TlvOperationCompletionEvent)
+        }
+    });
+
+    /**
+     * This cluster provides an interface for monitoring the operational state of an oven.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 8.10
+     */
+    export interface Cluster extends Identity<typeof ClusterInstance> {}
+
+    export const Cluster: Cluster = ClusterInstance;
+    export const Complete = Cluster;
+}
+
+export type OvenCavityOperationalStateCluster = OvenCavityOperationalState.Cluster;
+export const OvenCavityOperationalStateCluster = OvenCavityOperationalState.Cluster;
+ClusterRegistry.register(OvenCavityOperationalState.Complete);

package/src/clusters/oven-mode.ts

@@ -0,0 +1,259 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MutableCluster } from "../cluster/mutation/MutableCluster.js";
+import {
+    WritableAttribute,
+    FixedAttribute,
+    Attribute,
+    OptionalWritableAttribute,
+    Command,
+    TlvNoResponse
+} from "../cluster/Cluster.js";
+import { TlvUInt8 } from "../tlv/TlvNumber.js";
+import { TlvNullable } from "../tlv/TlvNullable.js";
+import { BitFlag } from "../schema/BitmapSchema.js";
+import { TlvArray } from "../tlv/TlvArray.js";
+import { ModeBase } from "./mode-base.js";
+import { Identity } from "#general";
+import { ClusterRegistry } from "../cluster/ClusterRegistry.js";
+
+export namespace OvenMode {
+    /**
+     * These are optional features supported by OvenModeCluster.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 1.10.4
+     */
+    export enum Feature {
+        /**
+         * OnOff (DEPONOFF)
+         *
+         * This feature creates a dependency between an OnOff cluster instance and this cluster instance on the same
+         * endpoint. See OnMode for more information.
+         *
+         * @see {@link MatterSpecification.v13.Cluster} § 1.10.4.1
+         */
+        OnOff = "OnOff"
+    }
+
+    export enum ModeTag {
+        /**
+         * This mode sets the device into baking mode for baking food items.
+         *
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1.1
+         */
+        Bake = 16384,
+
+        /**
+         * This mode sets the device into convection mode which creates an airflow within the device during the cooking
+         * duration.
+         *
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1.2
+         */
+        Convection = 16385,
+
+        /**
+         * This mode sets the device into grill mode for grilling food items. This is the same as Broil for many
+         * regions.
+         *
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1.3
+         */
+        Grill = 16386,
+
+        /**
+         * This mode sets the device into roast mode for roasting food items.
+         *
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1.4
+         */
+        Roast = 16387,
+
+        /**
+         * This mode sets the device into cleaning mode to clean the internal components of the appliance.
+         *
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1.5
+         */
+        Clean = 16388,
+
+        /**
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1
+         */
+        ConvectionBake = 16389,
+
+        /**
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1
+         */
+        ConvectionRoast = 16390,
+
+        /**
+         * This mode sets the device into a warming mode which begins warming the cavity.
+         *
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1.8
+         */
+        Warming = 16391,
+
+        /**
+         * This mode sets the device into proofing mode which creates an environment ready for proofing.
+         *
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1.9
+         */
+        Proofing = 16392,
+
+        /**
+         * @see {@link MatterSpecification.v13.Cluster} § 8.11.4.1
+         */
+        Steam = 16393
+    }
+
+    /**
+     * A OvenModeCluster supports these elements if it supports feature OnOff.
+     */
+    export const OnOffComponent = MutableCluster.Component({
+        attributes: {
+            /**
+             * Indicates whether the value of CurrentMode depends on the state of the On/Off cluster on the same
+             * endpoint. If this attribute is not present or is set to null, there is no dependency, otherwise the
+             * CurrentMode attribute shall depend on the OnOff attribute in the On/Off cluster
+             *
+             * The value of this field shall match the Mode field of one of the entries in the SupportedModes attribute.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.10.6.5
+             */
+            onMode: WritableAttribute(0x3, TlvNullable(TlvUInt8), { persistent: true, default: null })
+        }
+    });
+
+    /**
+     * These elements and properties are present in all OvenMode clusters.
+     */
+    export const Base = MutableCluster.Component({
+        id: 0x49,
+        name: "OvenMode",
+        revision: 1,
+
+        features: {
+            /**
+             * OnOff
+             *
+             * This feature creates a dependency between an OnOff cluster instance and this cluster instance on the
+             * same endpoint. See OnMode for more information.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.10.4.1
+             */
+            onOff: BitFlag(0)
+        },
+
+        attributes: {
+            /**
+             * This attribute shall contain the list of supported modes that may be selected for the CurrentMode
+             * attribute. Each item in this list represents a unique mode as indicated by the Mode field of the
+             * ModeOptionStruct.
+             *
+             * Each entry in this list shall have a unique value for the Mode field. Each entry in this list shall have
+             * a unique value for the Label field.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.10.6.2
+             */
+            supportedModes: FixedAttribute(0x0, TlvArray(ModeBase.TlvModeOption, { minLength: 2, maxLength: 255 })),
+
+            /**
+             * Indicates the current mode of the server.
+             *
+             * The value of this field shall match the Mode field of one of the entries in the SupportedModes attribute.
+             *
+             * The value of this attribute may change at any time via an out-of-band interaction outside of the server,
+             * such as interactions with a user interface, via internal mode changes due to autonomously progressing
+             * through a sequence of operations, on system time-outs or idle delays, or via interactions coming from a
+             * fabric other than the one which last executed a ChangeToMode.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.10.6.3
+             */
+            currentMode: Attribute(0x1, TlvUInt8, { scene: true, persistent: true }),
+
+            /**
+             * Indicates the desired startup mode for the server when it is supplied with power.
+             *
+             * If this attribute is not null, the CurrentMode attribute shall be set to the StartUpMode value, when the
+             * server is powered up, except in the case when the OnMode attribute overrides the StartUpMode attribute
+             * (see OnModeWithPowerUp).
+             *
+             * This behavior does not apply to reboots associated with OTA. After an OTA restart, the CurrentMode
+             * attribute shall return to its value prior to the restart.
+             *
+             * The value of this field shall match the Mode field of one of the entries in the SupportedModes attribute.
+             *
+             * If this attribute is not implemented, or is set to the null value, it shall have no effect.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.10.6.4
+             */
+            startUpMode: OptionalWritableAttribute(0x2, TlvNullable(TlvUInt8), { persistent: true })
+        },
+
+        commands: {
+            /**
+             * This command is used to change device modes.
+             *
+             * On receipt of this command the device shall respond with a ChangeToModeResponse command.
+             *
+             * @see {@link MatterSpecification.v13.Cluster} § 1.10.7.1
+             */
+            changeToMode: Command(0x0, ModeBase.TlvChangeToModeRequest, 0x0, TlvNoResponse)
+        },
+
+        /**
+         * This metadata controls which OvenModeCluster elements matter.js activates for specific feature combinations.
+         */
+        extensions: MutableCluster.Extensions({ flags: { onOff: true }, component: OnOffComponent })
+    });
+
+    /**
+     * @see {@link Cluster}
+     */
+    export const ClusterInstance = MutableCluster(Base);
+
+    /**
+     * This cluster is derived from the Mode Base cluster, defining additional mode tags and namespaced enumerated
+     * values for oven devices.
+     *
+     * OvenModeCluster supports optional features that you can enable with the OvenModeCluster.with() factory method.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 8.11
+     */
+    export interface Cluster extends Identity<typeof ClusterInstance> {}
+
+    export const Cluster: Cluster = ClusterInstance;
+    const DEPONOFF = { onOff: true };
+
+    /**
+     * @see {@link Complete}
+     */
+    export const CompleteInstance = MutableCluster({
+        id: Cluster.id,
+        name: Cluster.name,
+        revision: Cluster.revision,
+        features: Cluster.features,
+        attributes: {
+            ...Cluster.attributes,
+            onMode: MutableCluster.AsConditional(OnOffComponent.attributes.onMode, { mandatoryIf: [DEPONOFF] })
+        },
+        commands: Cluster.commands
+    });
+
+    /**
+     * This cluster supports all OvenMode 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.
+     */
+    export interface Complete extends Identity<typeof CompleteInstance> {}
+
+    export const Complete: Complete = CompleteInstance;
+}
+
+export type OvenModeCluster = OvenMode.Cluster;
+export const OvenModeCluster = OvenMode.Cluster;
+ClusterRegistry.register(OvenMode.Complete);

package/src/clusters/ozone-concentration-measurement.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MutableCluster } from "../cluster/mutation/MutableCluster.js";
+import { ConcentrationMeasurement } from "./concentration-measurement.js";
+import { Identity } from "#general";
+import { ClusterRegistry } from "../cluster/ClusterRegistry.js";
+
+export namespace OzoneConcentrationMeasurement {
+    export const Base = { ...ConcentrationMeasurement.Base, id: 0x415, name: "OzoneConcentrationMeasurement" } as const;
+
+    /**
+     * @see {@link Cluster}
+     */
+    export const ClusterInstance = MutableCluster.ExtensibleOnly(Base);
+
+    /**
+     * This alias specializes the semantics of {@link ConcentrationMeasurement.Base}.
+     *
+     * Per the Matter specification you cannot use {@link OzoneConcentrationMeasurementCluster} without enabling
+     * certain feature combinations. You must use the {@link with} factory method to obtain a working cluster.
+     */
+    export interface Cluster extends Identity<typeof ClusterInstance> {}
+
+    export const Cluster: Cluster = ClusterInstance;
+
+    /**
+     * This cluster supports all OzoneConcentrationMeasurement 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.
+     */
+    export const CompleteInstance = MutableCluster({
+        ...ConcentrationMeasurement.Complete,
+        id: 0x415,
+        name: "OzoneConcentrationMeasurement"
+    });
+
+    export interface Complete extends Identity<typeof CompleteInstance> {}
+    export const Complete: Complete = CompleteInstance;
+}
+
+export type OzoneConcentrationMeasurementCluster = OzoneConcentrationMeasurement.Cluster;
+export const OzoneConcentrationMeasurementCluster = OzoneConcentrationMeasurement.Cluster;
+ClusterRegistry.register(OzoneConcentrationMeasurement.Complete);

package/src/clusters/pm1-concentration-measurement.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MutableCluster } from "../cluster/mutation/MutableCluster.js";
+import { ConcentrationMeasurement } from "./concentration-measurement.js";
+import { Identity } from "#general";
+import { ClusterRegistry } from "../cluster/ClusterRegistry.js";
+
+export namespace Pm1ConcentrationMeasurement {
+    export const Base = { ...ConcentrationMeasurement.Base, id: 0x42c, name: "Pm1ConcentrationMeasurement" } as const;
+
+    /**
+     * @see {@link Cluster}
+     */
+    export const ClusterInstance = MutableCluster.ExtensibleOnly(Base);
+
+    /**
+     * This alias specializes the semantics of {@link ConcentrationMeasurement.Base}.
+     *
+     * Per the Matter specification you cannot use {@link Pm1ConcentrationMeasurementCluster} without enabling certain
+     * feature combinations. You must use the {@link with} factory method to obtain a working cluster.
+     */
+    export interface Cluster extends Identity<typeof ClusterInstance> {}
+
+    export const Cluster: Cluster = ClusterInstance;
+
+    /**
+     * This cluster supports all Pm1ConcentrationMeasurement 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.
+     */
+    export const CompleteInstance = MutableCluster({
+        ...ConcentrationMeasurement.Complete,
+        id: 0x42c,
+        name: "Pm1ConcentrationMeasurement"
+    });
+
+    export interface Complete extends Identity<typeof CompleteInstance> {}
+    export const Complete: Complete = CompleteInstance;
+}
+
+export type Pm1ConcentrationMeasurementCluster = Pm1ConcentrationMeasurement.Cluster;
+export const Pm1ConcentrationMeasurementCluster = Pm1ConcentrationMeasurement.Cluster;
+ClusterRegistry.register(Pm1ConcentrationMeasurement.Complete);