diff --git a/scripts/tools/zap_regen_all.py b/scripts/tools/zap_regen_all.py
index 27e6b1c5a83d46..bcccb6dd06e8b3 100755
--- a/scripts/tools/zap_regen_all.py
+++ b/scripts/tools/zap_regen_all.py
@@ -89,7 +89,7 @@ def getSpecificTemplatesTargets():
 
 def getTargets():
     targets = []
-    targets.extend(getGlobalTemplatesTargets())
+    #targets.extend(getGlobalTemplatesTargets())
     targets.extend(getSpecificTemplatesTargets())
     return targets
 
diff --git a/src/app/zap-templates/templates/app/cluster-objects.zapt b/src/app/zap-templates/templates/app/cluster-objects.zapt
index 36feed80ff5641..815004e79b22cc 100644
--- a/src/app/zap-templates/templates/app/cluster-objects.zapt
+++ b/src/app/zap-templates/templates/app/cluster-objects.zapt
@@ -11,6 +11,7 @@
 #include <app-common/zap-generated/enums.h>
 #include <app-common/zap-generated/ids/Commands.h>
 #include <app-common/zap-generated/ids/Clusters.h>
+#include <app-common/zap-generated/ids/Attributes.h>
 
 namespace chip {
 namespace app {
@@ -130,6 +131,43 @@ public:
 } // namespace Commands
 {{/last}}
 {{/zcl_commands}}
+
+{{#zcl_attributes_server}}
+{{#if (hasSpecificAttributes)}}
+{{#first}}
+namespace Attributes {
+{{/first}}
+{{#if clusterRef}}
+namespace {{asUpperCamelCase label}} {
+    {{#if arrayType}}
+    struct TypeInfo {
+        using Type = DataModel::List<{{#if_is_enum type}}{{arrayType}}{{else}}{{zapTypeToEncodableClusterObjectType arrayType}}{{/if_is_enum}}>;
+        static constexpr ClusterId GetClusterId() { return {{asUpperCamelCase parent.name}}::Id; }
+        static constexpr AttributeId GetAttributeId() { return Attributes::{{asUpperCamelCase label}}::Id; }
+    };
+    
+    struct DecodableTypeInfo {
+        using Type = DataModel::DecodableList<{{#if_is_enum type}}{{arrayType}}{{else}}{{zapTypeToDecodableClusterObjectType arrayType}}{{/if_is_enum}}>;
+        static constexpr ClusterId GetClusterId() { return {{asUpperCamelCase parent.name}}::Id; }
+        static constexpr AttributeId GetAttributeId() { return Attributes::{{asUpperCamelCase label}}::Id; }
+
+    };
+    {{else}}
+    struct TypeInfo {
+        using Type = {{zapTypeToEncodableClusterObjectType type}};
+        static constexpr ClusterId GetClusterId() { return {{asUpperCamelCase parent.name}}::Id; }
+        static constexpr AttributeId GetAttributeId() { return Attributes::{{asUpperCamelCase label}}::Id; }
+    };
+    
+    using DecodableTypeInfo = TypeInfo;
+    {{/if}}
+} // namespace for {{asUpperCamelCase label}}
+{{/if}}
+{{#last}}
+} // Attributes
+{{/last}}
+{{/if}}
+{{/zcl_attributes_server}}
 } // namespace {{asUpperCamelCase name}}
 {{/zcl_clusters}}
 
diff --git a/src/app/zap-templates/templates/app/helper.js b/src/app/zap-templates/templates/app/helper.js
index e8282225f9dfd1..ce0f68375dd5bb 100644
--- a/src/app/zap-templates/templates/app/helper.js
+++ b/src/app/zap-templates/templates/app/helper.js
@@ -407,8 +407,13 @@ function zapTypeToClusterObjectType(type, isDecodable)
     return 'uint24_t';
   case 'INT32U':
     return 'uint32_t';
+  case 'INT56U':
+  case 'int56u':
   case 'INT64U':
     return 'uint64_t';
+  case 'single':
+  case 'SINGLE':
+    return 'float';
   }
 
   function fn(pkgId)
@@ -428,6 +433,7 @@ function zapTypeToClusterObjectType(type, isDecodable)
       case 'uint32_t':
       case 'int64_t':
       case 'uint64_t':
+      case 'float':
         return zclType;
       default:
         if (isDecodable) {
diff --git a/src/app/zap-templates/zcl/data-model/silabs/general.xml b/src/app/zap-templates/zcl/data-model/silabs/general.xml
index 5af1f48a1bbf2f..e93f92a95a0b4f 100644
--- a/src/app/zap-templates/zcl/data-model/silabs/general.xml
+++ b/src/app/zap-templates/zcl/data-model/silabs/general.xml
@@ -343,7 +343,7 @@ limitations under the License.
     <attribute side="server" code="0x0003" define="SCENE_VALID" type="BOOLEAN" min="0x00" max="0x01" writable="false" default="0x00" optional="false">scene valid</attribute>
     <attribute side="server" code="0x0004" define="SCENE_NAME_SUPPORT" type="BITMAP8" min="0x00" max="0x80" writable="false" optional="false">name support</attribute>
     <!-- NAME_SUPPORT -->
-    <attribute side="server" code="0x0005" define="LAST_CONFIGURED_BY" type="EUI64" writable="false" optional="true">last configured by</attribute>
+    <attribute side="server" code="0x0005" define="LAST_CONFIGURED_BY" type="NODE_ID" writable="false" optional="true">last configured by</attribute>
     <command source="client" code="0x00" name="AddScene" optional="false" cli="zcl scenes add">
       <description>
         Add a scene to the scene table. Extension field sets are supported, and are inputed as arrays of the form [[cluster ID] [length] [value0...n] ...]
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
index e02a88d0f5aeac..3c9664350fd359 100644
--- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
+++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
@@ -1082,6 +1082,21 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint8_t nameSupport)
 
 } // namespace NameSupport
 
+namespace LastConfiguredBy {
+
+EmberAfStatus Get(chip::EndpointId endpoint, chip::NodeId * lastConfiguredBy)
+{
+    return emberAfReadServerAttribute(endpoint, Scenes::Id, LastConfiguredBy::Id, (uint8_t *) lastConfiguredBy,
+                                      sizeof(*lastConfiguredBy));
+}
+EmberAfStatus Set(chip::EndpointId endpoint, chip::NodeId lastConfiguredBy)
+{
+    return emberAfWriteServerAttribute(endpoint, Scenes::Id, LastConfiguredBy::Id, (uint8_t *) &lastConfiguredBy,
+                                       ZCL_NODE_ID_ATTRIBUTE_TYPE);
+}
+
+} // namespace LastConfiguredBy
+
 } // namespace Attributes
 } // namespace Scenes
 
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
index 802093e36f03d5..1534ac0997c0fa 100644
--- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
+++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
@@ -403,6 +403,11 @@ EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * nameSupport); // bitmap8
 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t nameSupport);
 } // namespace NameSupport
 
+namespace LastConfiguredBy {
+EmberAfStatus Get(chip::EndpointId endpoint, chip::NodeId * lastConfiguredBy); // node_id
+EmberAfStatus Set(chip::EndpointId endpoint, chip::NodeId lastConfiguredBy);
+} // namespace LastConfiguredBy
+
 } // namespace Attributes
 } // namespace Scenes
 
diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h
index 878e6b339027f2..f0bd2f78d95d65 100644
--- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h
+++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h
@@ -20,6 +20,7 @@
 #pragma once
 
 #include <app-common/zap-generated/enums.h>
+#include <app-common/zap-generated/ids/Attributes.h>
 #include <app-common/zap-generated/ids/Clusters.h>
 #include <app-common/zap-generated/ids/Commands.h>
 #include <app/data-model/DecodableList.h>
@@ -35,9 +36,673 @@ namespace Clusters {
 
 namespace PowerConfiguration {
 
+namespace Attributes {
+namespace MainsVoltage {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MainsVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MainsVoltage
+namespace MainsFrequency {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MainsFrequency::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MainsFrequency
+namespace MainsAlarmMask {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MainsAlarmMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MainsAlarmMask
+namespace MainsVoltageMinThreshold {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MainsVoltageMinThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MainsVoltageMinThreshold
+namespace MainsVoltageMaxThreshold {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MainsVoltageMaxThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MainsVoltageMaxThreshold
+namespace MainsVoltageDwellTrip {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MainsVoltageDwellTrip::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MainsVoltageDwellTrip
+namespace BatteryVoltage {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryVoltage
+namespace BatteryPercentageRemaining {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryPercentageRemaining::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryPercentageRemaining
+namespace BatteryManufacturer {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryManufacturer::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryManufacturer
+namespace BatterySize {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatterySize::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatterySize
+namespace BatteryAhrRating {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryAhrRating::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryAhrRating
+namespace BatteryQuantity {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryQuantity::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryQuantity
+namespace BatteryRatedVoltage {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryRatedVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryRatedVoltage
+namespace BatteryAlarmMask {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryAlarmMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryAlarmMask
+namespace BatteryVoltageMinThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryVoltageMinThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryVoltageMinThreshold
+namespace BatteryVoltageThreshold1 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryVoltageThreshold1::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryVoltageThreshold1
+namespace BatteryVoltageThreshold2 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryVoltageThreshold2::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryVoltageThreshold2
+namespace BatteryVoltageThreshold3 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryVoltageThreshold3::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryVoltageThreshold3
+namespace BatteryPercentageMinThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryPercentageMinThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryPercentageMinThreshold
+namespace BatteryPercentageThreshold1 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryPercentageThreshold1::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryPercentageThreshold1
+namespace BatteryPercentageThreshold2 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryPercentageThreshold2::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryPercentageThreshold2
+namespace BatteryPercentageThreshold3 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryPercentageThreshold3::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryPercentageThreshold3
+namespace BatteryAlarmState {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryAlarmState::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryAlarmState
+namespace Battery2Voltage {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2Voltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2Voltage
+namespace Battery2PercentageRemaining {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2PercentageRemaining::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2PercentageRemaining
+namespace Battery2Manufacturer {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2Manufacturer::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2Manufacturer
+namespace Battery2Size {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2Size::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2Size
+namespace Battery2AhrRating {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2AhrRating::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2AhrRating
+namespace Battery2Quantity {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2Quantity::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2Quantity
+namespace Battery2RatedVoltage {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2RatedVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2RatedVoltage
+namespace Battery2AlarmMask {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2AlarmMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2AlarmMask
+namespace Battery2VoltageMinThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2VoltageMinThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2VoltageMinThreshold
+namespace Battery2VoltageThreshold1 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2VoltageThreshold1::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2VoltageThreshold1
+namespace Battery2VoltageThreshold2 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2VoltageThreshold2::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2VoltageThreshold2
+namespace Battery2VoltageThreshold3 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2VoltageThreshold3::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2VoltageThreshold3
+namespace Battery2PercentageMinThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2PercentageMinThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2PercentageMinThreshold
+namespace Battery2PercentageThreshold1 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2PercentageThreshold1::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2PercentageThreshold1
+namespace Battery2PercentageThreshold2 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2PercentageThreshold2::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2PercentageThreshold2
+namespace Battery2PercentageThreshold3 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2PercentageThreshold3::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2PercentageThreshold3
+namespace Battery2AlarmState {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery2AlarmState::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery2AlarmState
+namespace Battery3Voltage {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3Voltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3Voltage
+namespace Battery3PercentageRemaining {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3PercentageRemaining::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3PercentageRemaining
+namespace Battery3Manufacturer {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3Manufacturer::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3Manufacturer
+namespace Battery3Size {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3Size::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3Size
+namespace Battery3AhrRating {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3AhrRating::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3AhrRating
+namespace Battery3Quantity {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3Quantity::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3Quantity
+namespace Battery3RatedVoltage {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3RatedVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3RatedVoltage
+namespace Battery3AlarmMask {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3AlarmMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3AlarmMask
+namespace Battery3VoltageMinThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3VoltageMinThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3VoltageMinThreshold
+namespace Battery3VoltageThreshold1 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3VoltageThreshold1::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3VoltageThreshold1
+namespace Battery3VoltageThreshold2 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3VoltageThreshold2::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3VoltageThreshold2
+namespace Battery3VoltageThreshold3 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3VoltageThreshold3::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3VoltageThreshold3
+namespace Battery3PercentageMinThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3PercentageMinThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3PercentageMinThreshold
+namespace Battery3PercentageThreshold1 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3PercentageThreshold1::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3PercentageThreshold1
+namespace Battery3PercentageThreshold2 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3PercentageThreshold2::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3PercentageThreshold2
+namespace Battery3PercentageThreshold3 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3PercentageThreshold3::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3PercentageThreshold3
+namespace Battery3AlarmState {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Battery3AlarmState::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Battery3AlarmState
+} // namespace Attributes
 } // namespace PowerConfiguration
 namespace DeviceTemperatureConfiguration {
 
+namespace Attributes {
+namespace CurrentTemperature {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentTemperature::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentTemperature
+namespace MinTempExperienced {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinTempExperienced::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinTempExperienced
+namespace MaxTempExperienced {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxTempExperienced::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxTempExperienced
+namespace OverTempTotalDwell {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OverTempTotalDwell::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OverTempTotalDwell
+namespace DeviceTempAlarmMask {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DeviceTempAlarmMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DeviceTempAlarmMask
+namespace LowTempThreshold {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LowTempThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LowTempThreshold
+namespace HighTempThreshold {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HighTempThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace HighTempThreshold
+namespace LowTempDwellTripPoint {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LowTempDwellTripPoint::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LowTempDwellTripPoint
+namespace HighTempDwellTripPoint {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return DeviceTemperatureConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HighTempDwellTripPoint::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace HighTempDwellTripPoint
+} // namespace Attributes
 } // namespace DeviceTemperatureConfiguration
 namespace Identify {
 // Need to convert consumers to using the new enum classes, so we
@@ -197,6 +862,29 @@ struct DecodableType
 };
 }; // namespace TriggerEffect
 } // namespace Commands
+
+namespace Attributes {
+namespace IdentifyTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::IdentifyTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace IdentifyTime
+namespace IdentifyType {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::IdentifyType::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace IdentifyType
+} // namespace Attributes
 } // namespace Identify
 namespace Groups {
 
@@ -505,6 +1193,19 @@ struct DecodableType
 };
 }; // namespace AddGroupIfIdentifying
 } // namespace Commands
+
+namespace Attributes {
+namespace NameSupport {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NameSupport::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace NameSupport
+} // namespace Attributes
 } // namespace Groups
 namespace Scenes {
 
@@ -1196,6 +1897,69 @@ struct DecodableType
 };
 }; // namespace CopySceneResponse
 } // namespace Commands
+
+namespace Attributes {
+namespace SceneCount {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SceneCount::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SceneCount
+namespace CurrentScene {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentScene::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentScene
+namespace CurrentGroup {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentGroup::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentGroup
+namespace SceneValid {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SceneValid::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SceneValid
+namespace NameSupport {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NameSupport::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace NameSupport
+namespace LastConfiguredBy {
+struct TypeInfo
+{
+    using Type = chip::NodeId;
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LastConfiguredBy::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LastConfiguredBy
+} // namespace Attributes
 } // namespace Scenes
 namespace OnOff {
 // Need to convert consumers to using the new enum classes, so we
@@ -1518,26 +2282,141 @@ struct DecodableType
 };
 }; // namespace OnWithTimedOff
 } // namespace Commands
-} // namespace OnOff
-namespace OnOffSwitchConfiguration {
 
-} // namespace OnOffSwitchConfiguration
-namespace LevelControl {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for MoveMode
-enum class MoveMode : uint8_t
+namespace Attributes {
+namespace OnOff {
+struct TypeInfo
 {
-    MOVE_MODE_UP   = 0x00,
-    MOVE_MODE_DOWN = 0x01,
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OnOff::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using MoveMode                             = EmberAfMoveMode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OnOff
+namespace SampleMfgSpecificAttribute0x00000x1002 {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SampleMfgSpecificAttribute0x00000x1002::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SampleMfgSpecificAttribute0x00000x1002
+namespace SampleMfgSpecificAttribute0x00000x1049 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SampleMfgSpecificAttribute0x00000x1049::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SampleMfgSpecificAttribute0x00000x1049
+namespace SampleMfgSpecificAttribute0x00010x1002 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SampleMfgSpecificAttribute0x00010x1002::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SampleMfgSpecificAttribute0x00010x1002
+namespace SampleMfgSpecificAttribute0x00010x1040 {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SampleMfgSpecificAttribute0x00010x1040::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SampleMfgSpecificAttribute0x00010x1040
+namespace GlobalSceneControl {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::GlobalSceneControl::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace GlobalSceneControl
+namespace OnTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OnTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OnTime
+namespace OffWaitTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OffWaitTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OffWaitTime
+namespace StartUpOnOff {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StartUpOnOff::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace StartUpOnOff
+} // namespace Attributes
+} // namespace OnOff
+namespace OnOffSwitchConfiguration {
+
+namespace Attributes {
+namespace SwitchType {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OnOffSwitchConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SwitchType::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SwitchType
+namespace SwitchActions {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OnOffSwitchConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SwitchActions::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SwitchActions
+} // namespace Attributes
+} // namespace OnOffSwitchConfiguration
+namespace LevelControl {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for MoveMode
+enum class MoveMode : uint8_t
+{
+    MOVE_MODE_UP   = 0x00,
+    MOVE_MODE_DOWN = 0x01,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using MoveMode                             = EmberAfMoveMode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 // Enum for StepMode
 enum class StepMode : uint8_t
 {
@@ -1815,6 +2694,99 @@ struct DecodableType
 };
 }; // namespace StopWithOnOff
 } // namespace Commands
+
+namespace Attributes {
+namespace CurrentLevel {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentLevel::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentLevel
+namespace RemainingTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RemainingTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RemainingTime
+namespace Options {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Options::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Options
+namespace OnOffTransitionTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OnOffTransitionTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OnOffTransitionTime
+namespace OnLevel {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OnLevel::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OnLevel
+namespace OnTransitionTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OnTransitionTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OnTransitionTime
+namespace OffTransitionTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OffTransitionTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OffTransitionTime
+namespace DefaultMoveRate {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DefaultMoveRate::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DefaultMoveRate
+namespace StartUpCurrentLevel {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StartUpCurrentLevel::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace StartUpCurrentLevel
+} // namespace Attributes
 } // namespace LevelControl
 namespace Alarms {
 
@@ -1991,12 +2963,219 @@ struct DecodableType
 };
 }; // namespace ResetAlarmLog
 } // namespace Commands
+
+namespace Attributes {
+namespace AlarmCount {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AlarmCount::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AlarmCount
+} // namespace Attributes
 } // namespace Alarms
 namespace Time {
 
+namespace Attributes {
+namespace Time {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Time::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Time
+namespace TimeStatus {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TimeStatus::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TimeStatus
+namespace TimeZone {
+struct TypeInfo
+{
+    using Type = int32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TimeZone::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TimeZone
+namespace DstStart {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DstStart::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DstStart
+namespace DstEnd {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DstEnd::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DstEnd
+namespace DstShift {
+struct TypeInfo
+{
+    using Type = int32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DstShift::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DstShift
+namespace StandardTime {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StandardTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace StandardTime
+namespace LocalTime {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LocalTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LocalTime
+namespace LastSetTime {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LastSetTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LastSetTime
+namespace ValidUntilTime {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Time::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ValidUntilTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ValidUntilTime
+} // namespace Attributes
 } // namespace Time
 namespace BinaryInputBasic {
 
+namespace Attributes {
+namespace ActiveText {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveText::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActiveText
+namespace Description {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Description::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Description
+namespace InactiveText {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InactiveText::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace InactiveText
+namespace OutOfService {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OutOfService::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OutOfService
+namespace Polarity {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Polarity::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Polarity
+namespace PresentValue {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PresentValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PresentValue
+namespace Reliability {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Reliability::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Reliability
+namespace StatusFlags {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StatusFlags::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace StatusFlags
+namespace ApplicationType {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return BinaryInputBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationType::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ApplicationType
+} // namespace Attributes
 } // namespace BinaryInputBasic
 namespace PowerProfile {
 
@@ -2747,6 +3926,59 @@ struct DecodableType
 };
 }; // namespace GetPowerProfilePriceExtended
 } // namespace Commands
+
+namespace Attributes {
+namespace TotalProfileNum {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TotalProfileNum::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TotalProfileNum
+namespace MultipleScheduling {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MultipleScheduling::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MultipleScheduling
+namespace EnergyFormatting {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnergyFormatting::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnergyFormatting
+namespace EnergyRemote {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnergyRemote::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnergyRemote
+namespace ScheduleMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ScheduleMode::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ScheduleMode
+} // namespace Attributes
 } // namespace PowerProfile
 namespace ApplianceControl {
 // Need to convert consumers to using the new enum classes, so we
@@ -3043,6 +4275,39 @@ struct DecodableType
 };
 }; // namespace OverloadWarning
 } // namespace Commands
+
+namespace Attributes {
+namespace StartTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StartTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace StartTime
+namespace FinishTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::FinishTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace FinishTime
+namespace RemainingTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RemainingTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RemainingTime
+} // namespace Attributes
 } // namespace ApplianceControl
 namespace Descriptor {
 
@@ -3069,6 +4334,68 @@ using DecodableType = Type;
 } // namespace DeviceType
 } // namespace Structs
 
+namespace Attributes {
+namespace DeviceList {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::DeviceType::Type>;
+    static constexpr ClusterId GetClusterId() { return Descriptor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DeviceList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::DeviceType::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return Descriptor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DeviceList::Id; }
+};
+} // namespace DeviceList
+namespace ServerList {
+struct TypeInfo
+{
+    using Type = DataModel::List<chip::ClusterId>;
+    static constexpr ClusterId GetClusterId() { return Descriptor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ServerList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<chip::ClusterId>;
+    static constexpr ClusterId GetClusterId() { return Descriptor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ServerList::Id; }
+};
+} // namespace ServerList
+namespace ClientList {
+struct TypeInfo
+{
+    using Type = DataModel::List<chip::ClusterId>;
+    static constexpr ClusterId GetClusterId() { return Descriptor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ClientList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<chip::ClusterId>;
+    static constexpr ClusterId GetClusterId() { return Descriptor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ClientList::Id; }
+};
+} // namespace ClientList
+namespace PartsList {
+struct TypeInfo
+{
+    using Type = DataModel::List<chip::EndpointId>;
+    static constexpr ClusterId GetClusterId() { return Descriptor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PartsList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<chip::EndpointId>;
+    static constexpr ClusterId GetClusterId() { return Descriptor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PartsList::Id; }
+};
+} // namespace PartsList
+} // namespace Attributes
 } // namespace Descriptor
 namespace PollControl {
 
@@ -3209,6 +4536,79 @@ struct DecodableType
 };
 }; // namespace SetShortPollInterval
 } // namespace Commands
+
+namespace Attributes {
+namespace CheckInInterval {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CheckInInterval::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CheckInInterval
+namespace LongPollInterval {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LongPollInterval::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LongPollInterval
+namespace ShortPollInterval {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ShortPollInterval::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ShortPollInterval
+namespace FastPollTimeout {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::FastPollTimeout::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace FastPollTimeout
+namespace CheckInIntervalMin {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CheckInIntervalMin::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CheckInIntervalMin
+namespace LongPollIntervalMin {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LongPollIntervalMin::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LongPollIntervalMin
+namespace FastPollTimeoutMax {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::FastPollTimeoutMax::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace FastPollTimeoutMax
+} // namespace Attributes
 } // namespace PollControl
 namespace Basic {
 
@@ -3310,17 +4710,200 @@ struct DecodableType
 };
 }; // namespace Leave
 } // namespace Commands
-} // namespace Basic
-namespace OtaSoftwareUpdateProvider {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for OTAApplyUpdateAction
-enum class OTAApplyUpdateAction : uint8_t
+
+namespace Attributes {
+namespace InteractionModelVersion {
+struct TypeInfo
 {
-    OTA_APPLY_UPDATE_ACTION_PROCEED           = 0x00,
-    OTA_APPLY_UPDATE_ACTION_AWAIT_NEXT_ACTION = 0x01,
-    OTA_APPLY_UPDATE_ACTION_DISCONTINUE       = 0x02,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InteractionModelVersion::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace InteractionModelVersion
+namespace VendorName {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::VendorName::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace VendorName
+namespace VendorID {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::VendorID::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace VendorID
+namespace ProductName {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductName::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductName
+namespace ProductID {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductID::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductID
+namespace UserLabel {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UserLabel::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace UserLabel
+namespace Location {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Location::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Location
+namespace HardwareVersion {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersion::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace HardwareVersion
+namespace HardwareVersionString {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersionString::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace HardwareVersionString
+namespace SoftwareVersion {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersion::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SoftwareVersion
+namespace SoftwareVersionString {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersionString::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SoftwareVersionString
+namespace ManufacturingDate {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ManufacturingDate::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ManufacturingDate
+namespace PartNumber {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PartNumber::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PartNumber
+namespace ProductURL {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductURL::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductURL
+namespace ProductLabel {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductLabel::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductLabel
+namespace SerialNumber {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SerialNumber::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SerialNumber
+namespace LocalConfigDisabled {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LocalConfigDisabled::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LocalConfigDisabled
+namespace Reachable {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Reachable::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Reachable
+} // namespace Attributes
+} // namespace Basic
+namespace OtaSoftwareUpdateProvider {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for OTAApplyUpdateAction
+enum class OTAApplyUpdateAction : uint8_t
+{
+    OTA_APPLY_UPDATE_ACTION_PROCEED           = 0x00,
+    OTA_APPLY_UPDATE_ACTION_AWAIT_NEXT_ACTION = 0x01,
+    OTA_APPLY_UPDATE_ACTION_DISCONTINUE       = 0x02,
 };
 #else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 using OTAApplyUpdateAction                 = EmberAfOTAApplyUpdateAction;
@@ -3546,6 +5129,7 @@ struct DecodableType
 };
 }; // namespace ApplyUpdateRequestResponse
 } // namespace Commands
+
 } // namespace OtaSoftwareUpdateProvider
 namespace OtaSoftwareUpdateRequestor {
 // Need to convert consumers to using the new enum classes, so we
@@ -3601,9 +5185,359 @@ struct DecodableType
 };
 }; // namespace AnnounceOtaProvider
 } // namespace Commands
+
+namespace Attributes {
+namespace DefaultOtaProvider {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateRequestor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DefaultOtaProvider::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DefaultOtaProvider
+namespace UpdatePossible {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateRequestor::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UpdatePossible::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace UpdatePossible
+} // namespace Attributes
 } // namespace OtaSoftwareUpdateRequestor
 namespace PowerSource {
 
+namespace Attributes {
+namespace Status {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Status::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Status
+namespace Order {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Order::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Order
+namespace Description {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Description::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Description
+namespace WiredAssessedInputVoltage {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedInputVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WiredAssessedInputVoltage
+namespace WiredAssessedInputFrequency {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedInputFrequency::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WiredAssessedInputFrequency
+namespace WiredCurrentType {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WiredCurrentType::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WiredCurrentType
+namespace WiredAssessedCurrent {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedCurrent::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WiredAssessedCurrent
+namespace WiredNominalVoltage {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WiredNominalVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WiredNominalVoltage
+namespace WiredMaximumCurrent {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WiredMaximumCurrent::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WiredMaximumCurrent
+namespace WiredPresent {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WiredPresent::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WiredPresent
+namespace ActiveWiredFaults {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveWiredFaults::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveWiredFaults::Id; }
+};
+} // namespace ActiveWiredFaults
+namespace BatteryVoltage {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryVoltage
+namespace BatteryPercentRemaining {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryPercentRemaining::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryPercentRemaining
+namespace BatteryTimeRemaining {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryTimeRemaining::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryTimeRemaining
+namespace BatteryChargeLevel {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryChargeLevel::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryChargeLevel
+namespace BatteryReplacementNeeded {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryReplacementNeeded::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryReplacementNeeded
+namespace BatteryReplaceability {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryReplaceability::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryReplaceability
+namespace BatteryPresent {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryPresent::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryPresent
+namespace ActiveBatteryFaults {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatteryFaults::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatteryFaults::Id; }
+};
+} // namespace ActiveBatteryFaults
+namespace BatteryReplacementDescription {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryReplacementDescription::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryReplacementDescription
+namespace BatteryCommonDesignation {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryCommonDesignation::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryCommonDesignation
+namespace BatteryANSIDesignation {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryANSIDesignation::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryANSIDesignation
+namespace BatteryIECDesignation {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryIECDesignation::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryIECDesignation
+namespace BatteryApprovedChemistry {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryApprovedChemistry::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryApprovedChemistry
+namespace BatteryCapacity {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryCapacity::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryCapacity
+namespace BatteryQuantity {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryQuantity::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryQuantity
+namespace BatteryChargeState {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryChargeState::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryChargeState
+namespace BatteryTimeToFullCharge {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryTimeToFullCharge::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryTimeToFullCharge
+namespace BatteryFunctionalWhileCharging {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryFunctionalWhileCharging::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryFunctionalWhileCharging
+namespace BatteryChargingCurrent {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryChargingCurrent::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BatteryChargingCurrent
+namespace ActiveBatteryChargeFaults {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatteryChargeFaults::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return PowerSource::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatteryChargeFaults::Id; }
+};
+} // namespace ActiveBatteryChargeFaults
+} // namespace Attributes
 } // namespace PowerSource
 namespace GeneralCommissioning {
 // Need to convert consumers to using the new enum classes, so we
@@ -3844,6 +5778,64 @@ struct DecodableType
 };
 }; // namespace CommissioningCompleteResponse
 } // namespace Commands
+
+namespace Attributes {
+namespace Breadcrumb {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Breadcrumb::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Breadcrumb
+namespace BasicCommissioningInfoList {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::BasicCommissioningInfoType::Type>;
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BasicCommissioningInfoList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::BasicCommissioningInfoType::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BasicCommissioningInfoList::Id; }
+};
+} // namespace BasicCommissioningInfoList
+namespace RegulatoryConfigList {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RegulatoryConfigList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RegulatoryConfigList::Id; }
+};
+} // namespace RegulatoryConfigList
+namespace LocationCapabilityList {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LocationCapabilityList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LocationCapabilityList::Id; }
+};
+} // namespace LocationCapabilityList
+} // namespace Attributes
 } // namespace GeneralCommissioning
 namespace NetworkCommissioning {
 // Need to convert consumers to using the new enum classes, so we
@@ -4486,6 +6478,7 @@ struct DecodableType
 };
 }; // namespace GetLastNetworkCommissioningResult
 } // namespace Commands
+
 } // namespace NetworkCommissioning
 namespace DiagnosticLogs {
 // Need to convert consumers to using the new enum classes, so we
@@ -4602,6 +6595,7 @@ struct DecodableType
 };
 }; // namespace RetrieveLogsResponse
 } // namespace Commands
+
 } // namespace DiagnosticLogs
 namespace GeneralDiagnostics {
 // Need to convert consumers to using the new enum classes, so we
@@ -4720,6 +6714,108 @@ using DecodableType = Type;
 } // namespace NetworkInterfaceType
 } // namespace Structs
 
+namespace Attributes {
+namespace NetworkInterfaces {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::NetworkInterfaceType::Type>;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NetworkInterfaces::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::NetworkInterfaceType::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NetworkInterfaces::Id; }
+};
+} // namespace NetworkInterfaces
+namespace RebootCount {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RebootCount::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RebootCount
+namespace UpTime {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UpTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace UpTime
+namespace TotalOperationalHours {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TotalOperationalHours::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TotalOperationalHours
+namespace BootReasons {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BootReasons::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BootReasons
+namespace ActiveHardwareFaults {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveHardwareFaults::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveHardwareFaults::Id; }
+};
+} // namespace ActiveHardwareFaults
+namespace ActiveRadioFaults {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveRadioFaults::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveRadioFaults::Id; }
+};
+} // namespace ActiveRadioFaults
+namespace ActiveNetworkFaults {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveNetworkFaults::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return GeneralDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveNetworkFaults::Id; }
+};
+} // namespace ActiveNetworkFaults
+} // namespace Attributes
 } // namespace GeneralDiagnostics
 namespace SoftwareDiagnostics {
 
@@ -4778,12 +6874,60 @@ struct DecodableType
 };
 }; // namespace ResetWatermarks
 } // namespace Commands
-} // namespace SoftwareDiagnostics
-namespace ThreadNetworkDiagnostics {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for NetworkFault
+
+namespace Attributes {
+namespace ThreadMetrics {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::ThreadMetrics::Type>;
+    static constexpr ClusterId GetClusterId() { return SoftwareDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ThreadMetrics::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::ThreadMetrics::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return SoftwareDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ThreadMetrics::Id; }
+};
+} // namespace ThreadMetrics
+namespace CurrentHeapFree {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return SoftwareDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapFree::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentHeapFree
+namespace CurrentHeapUsed {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return SoftwareDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapUsed::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentHeapUsed
+namespace CurrentHeapHighWatermark {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return SoftwareDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapHighWatermark::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentHeapHighWatermark
+} // namespace Attributes
+} // namespace SoftwareDiagnostics
+namespace ThreadNetworkDiagnostics {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for NetworkFault
 enum class NetworkFault : uint8_t
 {
     NETWORK_FAULT_UNSPECIFIED      = 0x00,
@@ -4981,604 +7125,711 @@ struct DecodableType
 };
 }; // namespace ResetCounts
 } // namespace Commands
-} // namespace ThreadNetworkDiagnostics
-namespace WiFiNetworkDiagnostics {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for SecurityType
-enum class SecurityType : uint8_t
+
+namespace Attributes {
+namespace Channel {
+struct TypeInfo
 {
-    SECURITY_TYPE_UNSPECIFIED = 0x00,
-    SECURITY_TYPE_NONE        = 0x01,
-    SECURITY_TYPE_WEP         = 0x02,
-    SECURITY_TYPE_WPA         = 0x03,
-    SECURITY_TYPE_WPA2        = 0x04,
-    SECURITY_TYPE_WPA3        = 0x05,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Channel::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using SecurityType                         = EmberAfSecurityType;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for WiFiVersionType
-enum class WiFiVersionType : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Channel
+namespace RoutingRole {
+struct TypeInfo
 {
-    WI_FI_VERSION_TYPE_802__11A  = 0x00,
-    WI_FI_VERSION_TYPE_802__11B  = 0x01,
-    WI_FI_VERSION_TYPE_802__11G  = 0x02,
-    WI_FI_VERSION_TYPE_802__11N  = 0x03,
-    WI_FI_VERSION_TYPE_802__11AC = 0x04,
-    WI_FI_VERSION_TYPE_802__11AX = 0x05,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RoutingRole::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using WiFiVersionType                      = EmberAfWiFiVersionType;
-#endif
 
-namespace Commands {
-namespace ResetCounts {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace RoutingRole
+namespace NetworkName {
+struct TypeInfo
 {
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NetworkName::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace NetworkName
+namespace PanId {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
-    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PanId::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace PanId
+namespace ExtendedPanId {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
-    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ExtendedPanId::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ExtendedPanId
+namespace MeshLocalPrefix {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeshLocalPrefix::Id; }
 };
-}; // namespace ResetCounts
-} // namespace Commands
-} // namespace WiFiNetworkDiagnostics
-namespace EthernetNetworkDiagnostics {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for PHYRateType
-enum class PHYRateType : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeshLocalPrefix
+namespace OverrunCount {
+struct TypeInfo
 {
-    PHY_RATE_TYPE_10_M   = 0x00,
-    PHY_RATE_TYPE_100_M  = 0x01,
-    PHY_RATE_TYPE_1000_M = 0x02,
-    PHY_RATE_TYPE_2__5_G = 0x03,
-    PHY_RATE_TYPE_5_G    = 0x04,
-    PHY_RATE_TYPE_10_G   = 0x05,
-    PHY_RATE_TYPE_40_G   = 0x06,
-    PHY_RATE_TYPE_100_G  = 0x07,
-    PHY_RATE_TYPE_200_G  = 0x08,
-    PHY_RATE_TYPE_400_G  = 0x09,
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using PHYRateType                          = EmberAfPHYRateType;
-#endif
 
-namespace Commands {
-namespace ResetCounts {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace OverrunCount
+namespace NeighborTableList {
+struct TypeInfo
 {
+    using Type = DataModel::List<Structs::NeighborTable::Type>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NeighborTableList::Id; }
 };
 
-struct Type
+struct DecodableTypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
-    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    using Type = DataModel::DecodableList<Structs::NeighborTable::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NeighborTableList::Id; }
+};
+} // namespace NeighborTableList
+namespace RouteTableList {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::RouteTable::Type>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RouteTableList::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::RouteTable::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RouteTableList::Id; }
+};
+} // namespace RouteTableList
+namespace PartitionId {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PartitionId::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace PartitionId
+namespace Weighting {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
-    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Weighting::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Weighting
+namespace DataVersion {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DataVersion::Id; }
 };
-}; // namespace ResetCounts
-} // namespace Commands
-} // namespace EthernetNetworkDiagnostics
-namespace BridgedDeviceBasic {
 
-namespace Commands {
-namespace StartUp {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace DataVersion
+namespace StableDataVersion {
+struct TypeInfo
 {
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StableDataVersion::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace StableDataVersion
+namespace LeaderRouterId {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StartUp::Id; }
-    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LeaderRouterId::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace LeaderRouterId
+namespace DetachedRoleCount {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DetachedRoleCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace DetachedRoleCount
+namespace ChildRoleCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return StartUp::Id; }
-    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ChildRoleCount::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ChildRoleCount
+namespace RouterRoleCount {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RouterRoleCount::Id; }
 };
-}; // namespace StartUp
-namespace ShutDown {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RouterRoleCount
+namespace LeaderRoleCount {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LeaderRoleCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace LeaderRoleCount
+namespace AttachAttemptCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ShutDown::Id; }
-    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AttachAttemptCount::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AttachAttemptCount
+namespace PartitionIdChangeCount {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PartitionIdChangeCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace PartitionIdChangeCount
+namespace BetterPartitionAttachAttemptCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return ShutDown::Id; }
-    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BetterPartitionAttachAttemptCount::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace BetterPartitionAttachAttemptCount
+namespace ParentChangeCount {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ParentChangeCount::Id; }
 };
-}; // namespace ShutDown
-namespace Leave {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ParentChangeCount
+namespace TxTotalCount {
+struct TypeInfo
 {
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxTotalCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxTotalCount
+namespace TxUnicastCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Leave::Id; }
-    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxUnicastCount::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxUnicastCount
+namespace TxBroadcastCount {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxBroadcastCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxBroadcastCount
+namespace TxAckRequestedCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return Leave::Id; }
-    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxAckRequestedCount::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxAckRequestedCount
+namespace TxAckedCount {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxAckedCount::Id; }
 };
-}; // namespace Leave
-namespace ReachableChanged {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxAckedCount
+namespace TxNoAckRequestedCount {
+struct TypeInfo
 {
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxNoAckRequestedCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxNoAckRequestedCount
+namespace TxDataCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ReachableChanged::Id; }
-    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxDataCount::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxDataCount
+namespace TxDataPollCount {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxDataPollCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxDataPollCount
+namespace TxBeaconCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return ReachableChanged::Id; }
-    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxBeaconCount::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxBeaconCount
+namespace TxBeaconRequestCount {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxBeaconRequestCount::Id; }
 };
-}; // namespace ReachableChanged
-} // namespace Commands
-} // namespace BridgedDeviceBasic
-namespace Switch {
 
-} // namespace Switch
-namespace AdministratorCommissioning {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for StatusCode
-enum class StatusCode : uint8_t
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxBeaconRequestCount
+namespace TxOtherCount {
+struct TypeInfo
 {
-    STATUS_CODE_SUCCESS       = 0x00,
-    STATUS_CODE_BUSY          = 0x01,
-    STATUS_CODE_GENERAL_ERROR = 0x02,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxOtherCount::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using StatusCode                           = EmberAfStatusCode;
-#endif
 
-namespace Commands {
-namespace OpenCommissioningWindow {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxOtherCount
+namespace TxRetryCount {
+struct TypeInfo
 {
-    kCommissioningTimeout = 0,
-    kPAKEVerifier         = 1,
-    kDiscriminator        = 2,
-    kIterations           = 3,
-    kSalt                 = 4,
-    kPasscodeID           = 5,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxRetryCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxRetryCount
+namespace TxDirectMaxRetryExpiryCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return OpenCommissioningWindow::Id; }
-    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
-
-    uint16_t commissioningTimeout;
-    chip::ByteSpan PAKEVerifier;
-    uint16_t discriminator;
-    uint32_t iterations;
-    chip::ByteSpan salt;
-    uint16_t passcodeID;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxDirectMaxRetryExpiryCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxDirectMaxRetryExpiryCount
+namespace TxIndirectMaxRetryExpiryCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return OpenCommissioningWindow::Id; }
-    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
-
-    uint16_t commissioningTimeout;
-    chip::ByteSpan PAKEVerifier;
-    uint16_t discriminator;
-    uint32_t iterations;
-    chip::ByteSpan salt;
-    uint16_t passcodeID;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxIndirectMaxRetryExpiryCount::Id; }
 };
-}; // namespace OpenCommissioningWindow
-namespace OpenBasicCommissioningWindow {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxIndirectMaxRetryExpiryCount
+namespace TxErrCcaCount {
+struct TypeInfo
 {
-    kCommissioningTimeout = 0,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxErrCcaCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxErrCcaCount
+namespace TxErrAbortCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return OpenBasicCommissioningWindow::Id; }
-    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
-
-    uint16_t commissioningTimeout;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxErrAbortCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxErrAbortCount
+namespace TxErrBusyChannelCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return OpenBasicCommissioningWindow::Id; }
-    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
-
-    uint16_t commissioningTimeout;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxErrBusyChannelCount::Id; }
 };
-}; // namespace OpenBasicCommissioningWindow
-namespace RevokeCommissioning {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxErrBusyChannelCount
+namespace RxTotalCount {
+struct TypeInfo
 {
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxTotalCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxTotalCount
+namespace RxUnicastCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return RevokeCommissioning::Id; }
-    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxUnicastCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxUnicastCount
+namespace RxBroadcastCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return RevokeCommissioning::Id; }
-    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
-
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxBroadcastCount::Id; }
 };
-}; // namespace RevokeCommissioning
-} // namespace Commands
-} // namespace AdministratorCommissioning
-namespace OperationalCredentials {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for NodeOperationalCertStatus
-enum class NodeOperationalCertStatus : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxBroadcastCount
+namespace RxDataCount {
+struct TypeInfo
 {
-    NODE_OPERATIONAL_CERT_STATUS_SUCCESS                = 0x00,
-    NODE_OPERATIONAL_CERT_STATUS_INVALID_PUBLIC_KEY     = 0x01,
-    NODE_OPERATIONAL_CERT_STATUS_INVALID_NODE_OP_ID     = 0x02,
-    NODE_OPERATIONAL_CERT_STATUS_INVALID_NOC            = 0x03,
-    NODE_OPERATIONAL_CERT_STATUS_MISSING_CSR            = 0x04,
-    NODE_OPERATIONAL_CERT_STATUS_TABLE_FULL             = 0x05,
-    NODE_OPERATIONAL_CERT_STATUS_INSUFFICIENT_PRIVILEGE = 0x08,
-    NODE_OPERATIONAL_CERT_STATUS_FABRIC_CONFLICT        = 0x09,
-    NODE_OPERATIONAL_CERT_STATUS_LABEL_CONFLICT         = 0x0A,
-    NODE_OPERATIONAL_CERT_STATUS_INVALID_FABRIC_INDEX   = 0x0B,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxDataCount::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using NodeOperationalCertStatus            = EmberAfNodeOperationalCertStatus;
-#endif
 
-namespace Structs {
-namespace FabricDescriptor {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxDataCount
+namespace RxDataPollCount {
+struct TypeInfo
 {
-    kFabricIndex   = 0,
-    kRootPublicKey = 1,
-    kVendorId      = 2,
-    kFabricId      = 3,
-    kNodeId        = 4,
-    kLabel         = 5,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxDataPollCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxDataPollCount
+namespace RxBeaconCount {
+struct TypeInfo
 {
-public:
-    uint8_t fabricIndex;
-    chip::ByteSpan rootPublicKey;
-    uint16_t vendorId;
-    chip::FabricId fabricId;
-    chip::NodeId nodeId;
-    chip::ByteSpan label;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxBeaconCount::Id; }
 };
 
-using DecodableType = Type;
-
-} // namespace FabricDescriptor
-namespace NOCStruct {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxBeaconCount
+namespace RxBeaconRequestCount {
+struct TypeInfo
 {
-    kFabricIndex = 0,
-    kNoc         = 1,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxBeaconRequestCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxBeaconRequestCount
+namespace RxOtherCount {
+struct TypeInfo
 {
-public:
-    uint8_t fabricIndex;
-    chip::ByteSpan noc;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxOtherCount::Id; }
 };
 
-using DecodableType = Type;
-
-} // namespace NOCStruct
-} // namespace Structs
-
-namespace Commands {
-namespace AttestationRequest {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxOtherCount
+namespace RxAddressFilteredCount {
+struct TypeInfo
 {
-    kAttestationNonce = 0,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxAddressFilteredCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxAddressFilteredCount
+namespace RxDestAddrFilteredCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return AttestationRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan attestationNonce;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxDestAddrFilteredCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxDestAddrFilteredCount
+namespace RxDuplicatedCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return AttestationRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan attestationNonce;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxDuplicatedCount::Id; }
 };
-}; // namespace AttestationRequest
-namespace AttestationResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxDuplicatedCount
+namespace RxErrNoFrameCount {
+struct TypeInfo
 {
-    kAttestationElements = 0,
-    kSignature           = 1,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxErrNoFrameCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxErrNoFrameCount
+namespace RxErrUnknownNeighborCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return AttestationResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan attestationElements;
-    chip::ByteSpan signature;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxErrUnknownNeighborCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxErrUnknownNeighborCount
+namespace RxErrInvalidSrcAddrCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return AttestationResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan attestationElements;
-    chip::ByteSpan signature;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxErrInvalidSrcAddrCount::Id; }
 };
-}; // namespace AttestationResponse
-namespace CertificateChainRequest {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxErrInvalidSrcAddrCount
+namespace RxErrSecCount {
+struct TypeInfo
 {
-    kCertificateType = 0,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxErrSecCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxErrSecCount
+namespace RxErrFcsCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return CertificateChainRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    uint8_t certificateType;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxErrFcsCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxErrFcsCount
+namespace RxErrOtherCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return CertificateChainRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    uint8_t certificateType;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RxErrOtherCount::Id; }
 };
-}; // namespace CertificateChainRequest
-namespace CertificateChainResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RxErrOtherCount
+namespace ActiveTimestamp {
+struct TypeInfo
 {
-    kCertificate = 0,
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveTimestamp::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActiveTimestamp
+namespace PendingTimestamp {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return CertificateChainResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan certificate;
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PendingTimestamp::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace PendingTimestamp
+namespace Delay {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Delay::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace Delay
+namespace SecurityPolicy {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return CertificateChainResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    using Type = DataModel::List<Structs::SecurityPolicy::Type>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SecurityPolicy::Id; }
+};
 
-    chip::ByteSpan certificate;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::SecurityPolicy::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SecurityPolicy::Id; }
 };
-}; // namespace CertificateChainResponse
-namespace OpCSRRequest {
-enum class Fields
+} // namespace SecurityPolicy
+namespace ChannelMask {
+struct TypeInfo
 {
-    kCSRNonce = 0,
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ChannelMask::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ChannelMask
+namespace OperationalDatasetComponents {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return OpCSRRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan CSRNonce;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = DataModel::List<Structs::OperationalDatasetComponents::Type>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OperationalDatasetComponents::Id; }
 };
 
-struct DecodableType
+struct DecodableTypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return OpCSRRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan CSRNonce;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = DataModel::DecodableList<Structs::OperationalDatasetComponents::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OperationalDatasetComponents::Id; }
 };
-}; // namespace OpCSRRequest
-namespace OpCSRResponse {
-enum class Fields
+} // namespace OperationalDatasetComponents
+namespace ActiveNetworkFaultsList {
+struct TypeInfo
 {
-    kNOCSRElements        = 0,
-    kAttestationSignature = 1,
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveNetworkFaultsList::Id; }
 };
 
-struct Type
+struct DecodableTypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return OpCSRResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan NOCSRElements;
-    chip::ByteSpan attestationSignature;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveNetworkFaultsList::Id; }
 };
-
-struct DecodableType
+} // namespace ActiveNetworkFaultsList
+} // namespace Attributes
+} // namespace ThreadNetworkDiagnostics
+namespace WiFiNetworkDiagnostics {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for SecurityType
+enum class SecurityType : uint8_t
 {
-public:
-    static constexpr CommandId GetCommandId() { return OpCSRResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan NOCSRElements;
-    chip::ByteSpan attestationSignature;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    SECURITY_TYPE_UNSPECIFIED = 0x00,
+    SECURITY_TYPE_NONE        = 0x01,
+    SECURITY_TYPE_WEP         = 0x02,
+    SECURITY_TYPE_WPA         = 0x03,
+    SECURITY_TYPE_WPA2        = 0x04,
+    SECURITY_TYPE_WPA3        = 0x05,
 };
-}; // namespace OpCSRResponse
-namespace AddNOC {
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using SecurityType                         = EmberAfSecurityType;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for WiFiVersionType
+enum class WiFiVersionType : uint8_t
+{
+    WI_FI_VERSION_TYPE_802__11A  = 0x00,
+    WI_FI_VERSION_TYPE_802__11B  = 0x01,
+    WI_FI_VERSION_TYPE_802__11G  = 0x02,
+    WI_FI_VERSION_TYPE_802__11N  = 0x03,
+    WI_FI_VERSION_TYPE_802__11AC = 0x04,
+    WI_FI_VERSION_TYPE_802__11AX = 0x05,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using WiFiVersionType                      = EmberAfWiFiVersionType;
+#endif
+
+namespace Commands {
+namespace ResetCounts {
 enum class Fields
 {
-    kNOCValue      = 0,
-    kICACValue     = 1,
-    kIPKValue      = 2,
-    kCaseAdminNode = 3,
-    kAdminVendorId = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return AddNOC::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan NOCValue;
-    chip::ByteSpan ICACValue;
-    chip::ByteSpan IPKValue;
-    chip::NodeId caseAdminNode;
-    uint16_t adminVendorId;
+    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -5586,124 +7837,181 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return AddNOC::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
 
-    chip::ByteSpan NOCValue;
-    chip::ByteSpan ICACValue;
-    chip::ByteSpan IPKValue;
-    chip::NodeId caseAdminNode;
-    uint16_t adminVendorId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace AddNOC
-namespace UpdateNOC {
-enum class Fields
+}; // namespace ResetCounts
+} // namespace Commands
+
+namespace Attributes {
+namespace Bssid {
+struct TypeInfo
 {
-    kNOCValue  = 0,
-    kICACValue = 1,
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Bssid::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Bssid
+namespace SecurityType {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return UpdateNOC::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan NOCValue;
-    chip::ByteSpan ICACValue;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SecurityType::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace SecurityType
+namespace WiFiVersion {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return UpdateNOC::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan NOCValue;
-    chip::ByteSpan ICACValue;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WiFiVersion::Id; }
 };
-}; // namespace UpdateNOC
-namespace NOCResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WiFiVersion
+namespace ChannelNumber {
+struct TypeInfo
 {
-    kStatusCode  = 0,
-    kFabricIndex = 1,
-    kDebugText   = 2,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ChannelNumber::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ChannelNumber
+namespace Rssi {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return NOCResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    uint8_t statusCode;
-    uint8_t fabricIndex;
-    chip::ByteSpan debugText;
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Rssi::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Rssi
+namespace BeaconLostCount {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BeaconLostCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace BeaconLostCount
+namespace BeaconRxCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return NOCResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BeaconRxCount::Id; }
+};
 
-    uint8_t statusCode;
-    uint8_t fabricIndex;
-    chip::ByteSpan debugText;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace BeaconRxCount
+namespace PacketMulticastRxCount {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PacketMulticastRxCount::Id; }
 };
-}; // namespace NOCResponse
-namespace UpdateFabricLabel {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PacketMulticastRxCount
+namespace PacketMulticastTxCount {
+struct TypeInfo
 {
-    kLabel = 0,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PacketMulticastTxCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace PacketMulticastTxCount
+namespace PacketUnicastRxCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return UpdateFabricLabel::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PacketUnicastRxCount::Id; }
+};
 
-    Span<const char> label;
+using DecodableTypeInfo = TypeInfo;
+} // namespace PacketUnicastRxCount
+namespace PacketUnicastTxCount {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PacketUnicastTxCount::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace PacketUnicastTxCount
+namespace CurrentMaxRate {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMaxRate::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentMaxRate
+namespace OverrunCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return UpdateFabricLabel::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; }
+};
 
-    Span<const char> label;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace OverrunCount
+} // namespace Attributes
+} // namespace WiFiNetworkDiagnostics
+namespace EthernetNetworkDiagnostics {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for PHYRateType
+enum class PHYRateType : uint8_t
+{
+    PHY_RATE_TYPE_10_M   = 0x00,
+    PHY_RATE_TYPE_100_M  = 0x01,
+    PHY_RATE_TYPE_1000_M = 0x02,
+    PHY_RATE_TYPE_2__5_G = 0x03,
+    PHY_RATE_TYPE_5_G    = 0x04,
+    PHY_RATE_TYPE_10_G   = 0x05,
+    PHY_RATE_TYPE_40_G   = 0x06,
+    PHY_RATE_TYPE_100_G  = 0x07,
+    PHY_RATE_TYPE_200_G  = 0x08,
+    PHY_RATE_TYPE_400_G  = 0x09,
 };
-}; // namespace UpdateFabricLabel
-namespace RemoveFabric {
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using PHYRateType                          = EmberAfPHYRateType;
+#endif
+
+namespace Commands {
+namespace ResetCounts {
 enum class Fields
 {
-    kFabricIndex = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return RemoveFabric::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    uint8_t fabricIndex;
+    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -5711,203 +8019,121 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return RemoveFabric::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
 
-    uint8_t fabricIndex;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace RemoveFabric
-namespace AddTrustedRootCertificate {
-enum class Fields
+}; // namespace ResetCounts
+} // namespace Commands
+
+namespace Attributes {
+namespace PHYRate {
+struct TypeInfo
 {
-    kRootCertificate = 0,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PHYRate::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace PHYRate
+namespace FullDuplex {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return AddTrustedRootCertificate::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan rootCertificate;
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::FullDuplex::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace FullDuplex
+namespace PacketRxCount {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PacketRxCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace PacketRxCount
+namespace PacketTxCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return AddTrustedRootCertificate::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan rootCertificate;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
-};
-}; // namespace AddTrustedRootCertificate
-namespace RemoveTrustedRootCertificate {
-enum class Fields
-{
-    kTrustedRootIdentifier = 0,
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PacketTxCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace PacketTxCount
+namespace TxErrCount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return RemoveTrustedRootCertificate::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan trustedRootIdentifier;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TxErrCount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace TxErrCount
+namespace CollisionCount {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return RemoveTrustedRootCertificate::Id; }
-    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
-
-    chip::ByteSpan trustedRootIdentifier;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CollisionCount::Id; }
 };
-}; // namespace RemoveTrustedRootCertificate
-} // namespace Commands
-} // namespace OperationalCredentials
-namespace FixedLabel {
 
-namespace Structs {
-namespace LabelStruct {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace CollisionCount
+namespace OverrunCount {
+struct TypeInfo
 {
-    kLabel = 0,
-    kValue = 1,
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace OverrunCount
+namespace CarrierDetect {
+struct TypeInfo
 {
-public:
-    chip::ByteSpan label;
-    chip::ByteSpan value;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CarrierDetect::Id; }
 };
 
-using DecodableType = Type;
-
-} // namespace LabelStruct
-} // namespace Structs
-
-} // namespace FixedLabel
-namespace ShadeConfiguration {
-
-} // namespace ShadeConfiguration
-namespace DoorLock {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for DoorLockOperationEventCode
-enum class DoorLockOperationEventCode : uint8_t
-{
-    DOOR_LOCK_OPERATION_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC  = 0x00,
-    DOOR_LOCK_OPERATION_EVENT_CODE_LOCK                     = 0x01,
-    DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK                   = 0x02,
-    DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_PIN_OR_ID   = 0x03,
-    DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_SCHEDULE    = 0x04,
-    DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_PIN_OR_ID = 0x05,
-    DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_SCHEDULE  = 0x06,
-    DOOR_LOCK_OPERATION_EVENT_CODE_ONE_TOUCH_LOCK           = 0x07,
-    DOOR_LOCK_OPERATION_EVENT_CODE_KEY_LOCK                 = 0x08,
-    DOOR_LOCK_OPERATION_EVENT_CODE_KEY_UNLOCK               = 0x09,
-    DOOR_LOCK_OPERATION_EVENT_CODE_AUTO_LOCK                = 0x0A,
-    DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_LOCK            = 0x0B,
-    DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_UNLOCK          = 0x0C,
-    DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_LOCK              = 0x0D,
-    DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_UNLOCK            = 0x0E,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using DoorLockOperationEventCode           = EmberAfDoorLockOperationEventCode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for DoorLockProgrammingEventCode
-enum class DoorLockProgrammingEventCode : uint8_t
-{
-    DOOR_LOCK_PROGRAMMING_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC = 0x00,
-    DOOR_LOCK_PROGRAMMING_EVENT_CODE_MASTER_CODE_CHANGED     = 0x01,
-    DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_ADDED               = 0x02,
-    DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_DELETED             = 0x03,
-    DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_CHANGED             = 0x04,
-    DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_ADDED                = 0x05,
-    DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_DELETED              = 0x06,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using DoorLockProgrammingEventCode         = EmberAfDoorLockProgrammingEventCode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for DoorLockSetPinOrIdStatus
-enum class DoorLockSetPinOrIdStatus : uint8_t
-{
-    DOOR_LOCK_SET_PIN_OR_ID_STATUS_SUCCESS              = 0x00,
-    DOOR_LOCK_SET_PIN_OR_ID_STATUS_GENERAL_FAILURE      = 0x01,
-    DOOR_LOCK_SET_PIN_OR_ID_STATUS_MEMORY_FULL          = 0x02,
-    DOOR_LOCK_SET_PIN_OR_ID_STATUS_DUPLICATE_CODE_ERROR = 0x03,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using DoorLockSetPinOrIdStatus             = EmberAfDoorLockSetPinOrIdStatus;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for DoorLockUserStatus
-enum class DoorLockUserStatus : uint8_t
-{
-    DOOR_LOCK_USER_STATUS_AVAILABLE         = 0x00,
-    DOOR_LOCK_USER_STATUS_OCCUPIED_ENABLED  = 0x01,
-    DOOR_LOCK_USER_STATUS_OCCUPIED_DISABLED = 0x03,
-    DOOR_LOCK_USER_STATUS_NOT_SUPPORTED     = 0xFF,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using DoorLockUserStatus                   = EmberAfDoorLockUserStatus;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for DoorLockUserType
-enum class DoorLockUserType : uint8_t
+using DecodableTypeInfo = TypeInfo;
+} // namespace CarrierDetect
+namespace TimeSinceReset {
+struct TypeInfo
 {
-    DOOR_LOCK_USER_TYPE_UNRESTRICTED           = 0x00,
-    DOOR_LOCK_USER_TYPE_YEAR_DAY_SCHEDULE_USER = 0x01,
-    DOOR_LOCK_USER_TYPE_WEEK_DAY_SCHEDULE_USER = 0x02,
-    DOOR_LOCK_USER_TYPE_MASTER_USER            = 0x03,
-    DOOR_LOCK_USER_TYPE_NON_ACCESS_USER        = 0x04,
-    DOOR_LOCK_USER_TYPE_NOT_SUPPORTED          = 0xFF,
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TimeSinceReset::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using DoorLockUserType                     = EmberAfDoorLockUserType;
-#endif
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TimeSinceReset
+} // namespace Attributes
+} // namespace EthernetNetworkDiagnostics
+namespace BridgedDeviceBasic {
 
 namespace Commands {
-namespace LockDoor {
+namespace StartUp {
 enum class Fields
 {
-    kPin = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LockDoor::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    chip::ByteSpan pin;
+    static constexpr CommandId GetCommandId() { return StartUp::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -5915,27 +8141,23 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return LockDoor::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return StartUp::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
-    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace LockDoor
-namespace LockDoorResponse {
+}; // namespace StartUp
+namespace ShutDown {
 enum class Fields
 {
-    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LockDoorResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    uint8_t status;
+    static constexpr CommandId GetCommandId() { return ShutDown::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -5943,27 +8165,23 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return LockDoorResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return ShutDown::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
-    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace LockDoorResponse
-namespace UnlockDoor {
+}; // namespace ShutDown
+namespace Leave {
 enum class Fields
 {
-    kPin = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return UnlockDoor::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    chip::ByteSpan pin;
+    static constexpr CommandId GetCommandId() { return Leave::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -5971,27 +8189,23 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return UnlockDoor::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return Leave::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
-    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace UnlockDoor
-namespace UnlockDoorResponse {
+}; // namespace Leave
+namespace ReachableChanged {
 enum class Fields
 {
-    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return UnlockDoorResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    uint8_t status;
+    static constexpr CommandId GetCommandId() { return ReachableChanged::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -5999,114 +8213,232 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return UnlockDoorResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return ReachableChanged::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
-    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace UnlockDoorResponse
-namespace Toggle {
-enum class Fields
+}; // namespace ReachableChanged
+} // namespace Commands
+
+namespace Attributes {
+namespace VendorName {
+struct TypeInfo
 {
-    kPin = 0,
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::VendorName::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace VendorName
+namespace VendorID {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Toggle::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    Span<const char> pin;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::VendorID::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace VendorID
+namespace ProductName {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return Toggle::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    Span<const char> pin;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductName::Id; }
 };
-}; // namespace Toggle
-namespace ToggleResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductName
+namespace UserLabel {
+struct TypeInfo
 {
-    kStatus = 0,
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UserLabel::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace UserLabel
+namespace HardwareVersion {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ToggleResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersion::Id; }
+};
 
-    uint8_t status;
+using DecodableTypeInfo = TypeInfo;
+} // namespace HardwareVersion
+namespace HardwareVersionString {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersionString::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace HardwareVersionString
+namespace SoftwareVersion {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersion::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace SoftwareVersion
+namespace SoftwareVersionString {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return ToggleResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersionString::Id; }
+};
 
-    uint8_t status;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace SoftwareVersionString
+namespace ManufacturingDate {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ManufacturingDate::Id; }
 };
-}; // namespace ToggleResponse
-namespace UnlockWithTimeout {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ManufacturingDate
+namespace PartNumber {
+struct TypeInfo
 {
-    kTimeoutInSeconds = 0,
-    kPin              = 1,
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PartNumber::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace PartNumber
+namespace ProductURL {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return UnlockWithTimeout::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductURL::Id; }
+};
 
-    uint16_t timeoutInSeconds;
-    chip::ByteSpan pin;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductURL
+namespace ProductLabel {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductLabel::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductLabel
+namespace SerialNumber {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SerialNumber::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace SerialNumber
+namespace Reachable {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return UnlockWithTimeout::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Reachable::Id; }
+};
 
-    uint16_t timeoutInSeconds;
-    chip::ByteSpan pin;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Reachable
+} // namespace Attributes
+} // namespace BridgedDeviceBasic
+namespace Switch {
+
+namespace Attributes {
+namespace NumberOfPositions {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Switch::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfPositions::Id; }
 };
-}; // namespace UnlockWithTimeout
-namespace UnlockWithTimeoutResponse {
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumberOfPositions
+namespace CurrentPosition {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Switch::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPosition::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentPosition
+namespace MultiPressMax {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Switch::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MultiPressMax::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MultiPressMax
+} // namespace Attributes
+} // namespace Switch
+namespace AdministratorCommissioning {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for StatusCode
+enum class StatusCode : uint8_t
+{
+    STATUS_CODE_SUCCESS       = 0x00,
+    STATUS_CODE_BUSY          = 0x01,
+    STATUS_CODE_GENERAL_ERROR = 0x02,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using StatusCode                           = EmberAfStatusCode;
+#endif
+
+namespace Commands {
+namespace OpenCommissioningWindow {
 enum class Fields
 {
-    kStatus = 0,
+    kCommissioningTimeout = 0,
+    kPAKEVerifier         = 1,
+    kDiscriminator        = 2,
+    kIterations           = 3,
+    kSalt                 = 4,
+    kPasscodeID           = 5,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return UnlockWithTimeoutResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return OpenCommissioningWindow::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
 
-    uint8_t status;
+    uint16_t commissioningTimeout;
+    chip::ByteSpan PAKEVerifier;
+    uint16_t discriminator;
+    uint32_t iterations;
+    chip::ByteSpan salt;
+    uint16_t passcodeID;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6114,27 +8446,32 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return UnlockWithTimeoutResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return OpenCommissioningWindow::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
 
-    uint8_t status;
+    uint16_t commissioningTimeout;
+    chip::ByteSpan PAKEVerifier;
+    uint16_t discriminator;
+    uint32_t iterations;
+    chip::ByteSpan salt;
+    uint16_t passcodeID;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace UnlockWithTimeoutResponse
-namespace GetLogRecord {
+}; // namespace OpenCommissioningWindow
+namespace OpenBasicCommissioningWindow {
 enum class Fields
 {
-    kLogIndex = 0,
+    kCommissioningTimeout = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetLogRecord::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return OpenBasicCommissioningWindow::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
 
-    uint16_t logIndex;
+    uint16_t commissioningTimeout;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6142,39 +8479,24 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetLogRecord::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return OpenBasicCommissioningWindow::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
 
-    uint16_t logIndex;
+    uint16_t commissioningTimeout;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetLogRecord
-namespace GetLogRecordResponse {
+}; // namespace OpenBasicCommissioningWindow
+namespace RevokeCommissioning {
 enum class Fields
 {
-    kLogEntryId         = 0,
-    kTimestamp          = 1,
-    kEventType          = 2,
-    kSource             = 3,
-    kEventIdOrAlarmCode = 4,
-    kUserId             = 5,
-    kPin                = 6,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetLogRecordResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    uint16_t logEntryId;
-    uint32_t timestamp;
-    uint8_t eventType;
-    uint8_t source;
-    uint8_t eventIdOrAlarmCode;
-    uint16_t userId;
-    chip::ByteSpan pin;
+    static constexpr CommandId GetCommandId() { return RevokeCommissioning::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6182,70 +8504,103 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetLogRecordResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return RevokeCommissioning::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
 
-    uint16_t logEntryId;
-    uint32_t timestamp;
-    uint8_t eventType;
-    uint8_t source;
-    uint8_t eventIdOrAlarmCode;
-    uint16_t userId;
-    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetLogRecordResponse
-namespace SetPin {
+}; // namespace RevokeCommissioning
+} // namespace Commands
+
+} // namespace AdministratorCommissioning
+namespace OperationalCredentials {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for NodeOperationalCertStatus
+enum class NodeOperationalCertStatus : uint8_t
+{
+    NODE_OPERATIONAL_CERT_STATUS_SUCCESS                = 0x00,
+    NODE_OPERATIONAL_CERT_STATUS_INVALID_PUBLIC_KEY     = 0x01,
+    NODE_OPERATIONAL_CERT_STATUS_INVALID_NODE_OP_ID     = 0x02,
+    NODE_OPERATIONAL_CERT_STATUS_INVALID_NOC            = 0x03,
+    NODE_OPERATIONAL_CERT_STATUS_MISSING_CSR            = 0x04,
+    NODE_OPERATIONAL_CERT_STATUS_TABLE_FULL             = 0x05,
+    NODE_OPERATIONAL_CERT_STATUS_INSUFFICIENT_PRIVILEGE = 0x08,
+    NODE_OPERATIONAL_CERT_STATUS_FABRIC_CONFLICT        = 0x09,
+    NODE_OPERATIONAL_CERT_STATUS_LABEL_CONFLICT         = 0x0A,
+    NODE_OPERATIONAL_CERT_STATUS_INVALID_FABRIC_INDEX   = 0x0B,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using NodeOperationalCertStatus            = EmberAfNodeOperationalCertStatus;
+#endif
+
+namespace Structs {
+namespace FabricDescriptor {
 enum class Fields
 {
-    kUserId     = 0,
-    kUserStatus = 1,
-    kUserType   = 2,
-    kPin        = 3,
+    kFabricIndex   = 0,
+    kRootPublicKey = 1,
+    kVendorId      = 2,
+    kFabricId      = 3,
+    kNodeId        = 4,
+    kLabel         = 5,
 };
 
 struct Type
 {
 public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetPin::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    uint16_t userId;
-    DoorLockUserStatus userStatus;
-    DoorLockUserType userType;
-    chip::ByteSpan pin;
+    uint8_t fabricIndex;
+    chip::ByteSpan rootPublicKey;
+    uint16_t vendorId;
+    chip::FabricId fabricId;
+    chip::NodeId nodeId;
+    chip::ByteSpan label;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
 
-struct DecodableType
+using DecodableType = Type;
+
+} // namespace FabricDescriptor
+namespace NOCStruct {
+enum class Fields
+{
+    kFabricIndex = 0,
+    kNoc         = 1,
+};
+
+struct Type
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetPin::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    uint8_t fabricIndex;
+    chip::ByteSpan noc;
 
-    uint16_t userId;
-    DoorLockUserStatus userStatus;
-    DoorLockUserType userType;
-    chip::ByteSpan pin;
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetPin
-namespace SetPinResponse {
+
+using DecodableType = Type;
+
+} // namespace NOCStruct
+} // namespace Structs
+
+namespace Commands {
+namespace AttestationRequest {
 enum class Fields
 {
-    kStatus = 0,
+    kAttestationNonce = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetPinResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return AttestationRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    DoorLockSetPinOrIdStatus status;
+    chip::ByteSpan attestationNonce;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6253,27 +8608,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetPinResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return AttestationRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    DoorLockSetPinOrIdStatus status;
+    chip::ByteSpan attestationNonce;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetPinResponse
-namespace GetPin {
+}; // namespace AttestationRequest
+namespace AttestationResponse {
 enum class Fields
 {
-    kUserId = 0,
+    kAttestationElements = 0,
+    kSignature           = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetPin::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return AttestationResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
+    chip::ByteSpan attestationElements;
+    chip::ByteSpan signature;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6281,33 +8638,28 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetPin::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return AttestationResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
+    chip::ByteSpan attestationElements;
+    chip::ByteSpan signature;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetPin
-namespace GetPinResponse {
+}; // namespace AttestationResponse
+namespace CertificateChainRequest {
 enum class Fields
 {
-    kUserId     = 0,
-    kUserStatus = 1,
-    kUserType   = 2,
-    kPin        = 3,
+    kCertificateType = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetPinResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return CertificateChainRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
-    DoorLockUserStatus userStatus;
-    DoorLockUserType userType;
-    chip::ByteSpan pin;
+    uint8_t certificateType;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6315,30 +8667,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetPinResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return CertificateChainRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
-    DoorLockUserStatus userStatus;
-    DoorLockUserType userType;
-    chip::ByteSpan pin;
+    uint8_t certificateType;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetPinResponse
-namespace ClearPin {
+}; // namespace CertificateChainRequest
+namespace CertificateChainResponse {
 enum class Fields
 {
-    kUserId = 0,
+    kCertificate = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearPin::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return CertificateChainResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
+    chip::ByteSpan certificate;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6346,27 +8695,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearPin::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return CertificateChainResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
+    chip::ByteSpan certificate;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearPin
-namespace ClearPinResponse {
+}; // namespace CertificateChainResponse
+namespace OpCSRRequest {
 enum class Fields
 {
-    kStatus = 0,
+    kCSRNonce = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearPinResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return OpCSRRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t status;
+    chip::ByteSpan CSRNonce;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6374,24 +8723,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearPinResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return OpCSRRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t status;
+    chip::ByteSpan CSRNonce;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearPinResponse
-namespace ClearAllPins {
+}; // namespace OpCSRRequest
+namespace OpCSRResponse {
 enum class Fields
 {
+    kNOCSRElements        = 0,
+    kAttestationSignature = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearAllPins::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return OpCSRResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+
+    chip::ByteSpan NOCSRElements;
+    chip::ByteSpan attestationSignature;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6399,26 +8753,36 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearAllPins::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return OpCSRResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    chip::ByteSpan NOCSRElements;
+    chip::ByteSpan attestationSignature;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearAllPins
-namespace ClearAllPinsResponse {
+}; // namespace OpCSRResponse
+namespace AddNOC {
 enum class Fields
 {
-    kStatus = 0,
+    kNOCValue      = 0,
+    kICACValue     = 1,
+    kIPKValue      = 2,
+    kCaseAdminNode = 3,
+    kAdminVendorId = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearAllPinsResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return AddNOC::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t status;
+    chip::ByteSpan NOCValue;
+    chip::ByteSpan ICACValue;
+    chip::ByteSpan IPKValue;
+    chip::NodeId caseAdminNode;
+    uint16_t adminVendorId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6426,29 +8790,33 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearAllPinsResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return AddNOC::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t status;
+    chip::ByteSpan NOCValue;
+    chip::ByteSpan ICACValue;
+    chip::ByteSpan IPKValue;
+    chip::NodeId caseAdminNode;
+    uint16_t adminVendorId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearAllPinsResponse
-namespace SetUserStatus {
+}; // namespace AddNOC
+namespace UpdateNOC {
 enum class Fields
 {
-    kUserId     = 0,
-    kUserStatus = 1,
+    kNOCValue  = 0,
+    kICACValue = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetUserStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return UpdateNOC::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
-    uint8_t userStatus;
+    chip::ByteSpan NOCValue;
+    chip::ByteSpan ICACValue;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6456,28 +8824,32 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetUserStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return UpdateNOC::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
-    uint8_t userStatus;
+    chip::ByteSpan NOCValue;
+    chip::ByteSpan ICACValue;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetUserStatus
-namespace SetUserStatusResponse {
+}; // namespace UpdateNOC
+namespace NOCResponse {
 enum class Fields
 {
-    kStatus = 0,
+    kStatusCode  = 0,
+    kFabricIndex = 1,
+    kDebugText   = 2,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetUserStatusResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return NOCResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t status;
+    uint8_t statusCode;
+    uint8_t fabricIndex;
+    chip::ByteSpan debugText;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6485,27 +8857,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetUserStatusResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return NOCResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t status;
+    uint8_t statusCode;
+    uint8_t fabricIndex;
+    chip::ByteSpan debugText;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetUserStatusResponse
-namespace GetUserStatus {
+}; // namespace NOCResponse
+namespace UpdateFabricLabel {
 enum class Fields
 {
-    kUserId = 0,
+    kLabel = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetUserStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return UpdateFabricLabel::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
+    Span<const char> label;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6513,29 +8887,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetUserStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return UpdateFabricLabel::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
+    Span<const char> label;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetUserStatus
-namespace GetUserStatusResponse {
+}; // namespace UpdateFabricLabel
+namespace RemoveFabric {
 enum class Fields
 {
-    kUserId = 0,
-    kStatus = 1,
+    kFabricIndex = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetUserStatusResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return RemoveFabric::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
-    uint8_t status;
+    uint8_t fabricIndex;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6543,40 +8915,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetUserStatusResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return RemoveFabric::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint16_t userId;
-    uint8_t status;
+    uint8_t fabricIndex;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetUserStatusResponse
-namespace SetWeekdaySchedule {
+}; // namespace RemoveFabric
+namespace AddTrustedRootCertificate {
 enum class Fields
 {
-    kScheduleId  = 0,
-    kUserId      = 1,
-    kDaysMask    = 2,
-    kStartHour   = 3,
-    kStartMinute = 4,
-    kEndHour     = 5,
-    kEndMinute   = 6,
+    kRootCertificate = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetWeekdaySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return AddTrustedRootCertificate::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
-    uint8_t daysMask;
-    uint8_t startHour;
-    uint8_t startMinute;
-    uint8_t endHour;
-    uint8_t endMinute;
+    chip::ByteSpan rootCertificate;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6584,33 +8943,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetWeekdaySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return AddTrustedRootCertificate::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
-    uint8_t daysMask;
-    uint8_t startHour;
-    uint8_t startMinute;
-    uint8_t endHour;
-    uint8_t endMinute;
+    chip::ByteSpan rootCertificate;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetWeekdaySchedule
-namespace SetWeekdayScheduleResponse {
+}; // namespace AddTrustedRootCertificate
+namespace RemoveTrustedRootCertificate {
 enum class Fields
 {
-    kStatus = 0,
+    kTrustedRootIdentifier = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetWeekdayScheduleResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return RemoveTrustedRootCertificate::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t status;
+    chip::ByteSpan trustedRootIdentifier;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6618,109 +8971,269 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetWeekdayScheduleResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr CommandId GetCommandId() { return RemoveTrustedRootCertificate::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
-    uint8_t status;
+    chip::ByteSpan trustedRootIdentifier;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetWeekdayScheduleResponse
-namespace GetWeekdaySchedule {
+}; // namespace RemoveTrustedRootCertificate
+} // namespace Commands
+
+namespace Attributes {
+namespace FabricsList {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::FabricDescriptor::Type>;
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::FabricsList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::FabricDescriptor::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::FabricsList::Id; }
+};
+} // namespace FabricsList
+namespace SupportedFabrics {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SupportedFabrics::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SupportedFabrics
+namespace CommissionedFabrics {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CommissionedFabrics::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CommissionedFabrics
+namespace TrustedRootCertificates {
+struct TypeInfo
+{
+    using Type = DataModel::List<chip::ByteSpan>;
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TrustedRootCertificates::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<chip::ByteSpan>;
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TrustedRootCertificates::Id; }
+};
+} // namespace TrustedRootCertificates
+} // namespace Attributes
+} // namespace OperationalCredentials
+namespace FixedLabel {
+
+namespace Structs {
+namespace LabelStruct {
 enum class Fields
 {
-    kScheduleId = 0,
-    kUserId     = 1,
+    kLabel = 0,
+    kValue = 1,
 };
 
 struct Type
 {
 public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetWeekdaySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
-
-    uint8_t scheduleId;
-    uint16_t userId;
+    chip::ByteSpan label;
+    chip::ByteSpan value;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
 
-struct DecodableType
+using DecodableType = Type;
+
+} // namespace LabelStruct
+} // namespace Structs
+
+namespace Attributes {
+namespace LabelList {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetWeekdaySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    using Type = DataModel::List<Structs::LabelStruct::Type>;
+    static constexpr ClusterId GetClusterId() { return FixedLabel::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LabelList::Id; }
+};
 
-    uint8_t scheduleId;
-    uint16_t userId;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::LabelStruct::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return FixedLabel::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LabelList::Id; }
 };
-}; // namespace GetWeekdaySchedule
-namespace GetWeekdayScheduleResponse {
-enum class Fields
+} // namespace LabelList
+} // namespace Attributes
+} // namespace FixedLabel
+namespace ShadeConfiguration {
+
+namespace Attributes {
+namespace PhysicalClosedLimit {
+struct TypeInfo
 {
-    kScheduleId  = 0,
-    kUserId      = 1,
-    kStatus      = 2,
-    kDaysMask    = 3,
-    kStartHour   = 4,
-    kStartMinute = 5,
-    kEndHour     = 6,
-    kEndMinute   = 7,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ShadeConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalClosedLimit::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhysicalClosedLimit
+namespace MotorStepSize {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetWeekdayScheduleResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ShadeConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MotorStepSize::Id; }
+};
 
-    uint8_t scheduleId;
-    uint16_t userId;
-    uint8_t status;
-    uint8_t daysMask;
-    uint8_t startHour;
-    uint8_t startMinute;
-    uint8_t endHour;
-    uint8_t endMinute;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MotorStepSize
+namespace Status {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ShadeConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Status::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Status
+namespace ClosedLimit {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ShadeConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ClosedLimit::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ClosedLimit
+namespace Mode {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetWeekdayScheduleResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ShadeConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Mode::Id; }
+};
 
-    uint8_t scheduleId;
-    uint16_t userId;
-    uint8_t status;
-    uint8_t daysMask;
-    uint8_t startHour;
-    uint8_t startMinute;
-    uint8_t endHour;
-    uint8_t endMinute;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Mode
+} // namespace Attributes
+} // namespace ShadeConfiguration
+namespace DoorLock {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for DoorLockOperationEventCode
+enum class DoorLockOperationEventCode : uint8_t
+{
+    DOOR_LOCK_OPERATION_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC  = 0x00,
+    DOOR_LOCK_OPERATION_EVENT_CODE_LOCK                     = 0x01,
+    DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK                   = 0x02,
+    DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_PIN_OR_ID   = 0x03,
+    DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_SCHEDULE    = 0x04,
+    DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_PIN_OR_ID = 0x05,
+    DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_SCHEDULE  = 0x06,
+    DOOR_LOCK_OPERATION_EVENT_CODE_ONE_TOUCH_LOCK           = 0x07,
+    DOOR_LOCK_OPERATION_EVENT_CODE_KEY_LOCK                 = 0x08,
+    DOOR_LOCK_OPERATION_EVENT_CODE_KEY_UNLOCK               = 0x09,
+    DOOR_LOCK_OPERATION_EVENT_CODE_AUTO_LOCK                = 0x0A,
+    DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_LOCK            = 0x0B,
+    DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_UNLOCK          = 0x0C,
+    DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_LOCK              = 0x0D,
+    DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_UNLOCK            = 0x0E,
 };
-}; // namespace GetWeekdayScheduleResponse
-namespace ClearWeekdaySchedule {
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using DoorLockOperationEventCode           = EmberAfDoorLockOperationEventCode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for DoorLockProgrammingEventCode
+enum class DoorLockProgrammingEventCode : uint8_t
+{
+    DOOR_LOCK_PROGRAMMING_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC = 0x00,
+    DOOR_LOCK_PROGRAMMING_EVENT_CODE_MASTER_CODE_CHANGED     = 0x01,
+    DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_ADDED               = 0x02,
+    DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_DELETED             = 0x03,
+    DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_CHANGED             = 0x04,
+    DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_ADDED                = 0x05,
+    DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_DELETED              = 0x06,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using DoorLockProgrammingEventCode         = EmberAfDoorLockProgrammingEventCode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for DoorLockSetPinOrIdStatus
+enum class DoorLockSetPinOrIdStatus : uint8_t
+{
+    DOOR_LOCK_SET_PIN_OR_ID_STATUS_SUCCESS              = 0x00,
+    DOOR_LOCK_SET_PIN_OR_ID_STATUS_GENERAL_FAILURE      = 0x01,
+    DOOR_LOCK_SET_PIN_OR_ID_STATUS_MEMORY_FULL          = 0x02,
+    DOOR_LOCK_SET_PIN_OR_ID_STATUS_DUPLICATE_CODE_ERROR = 0x03,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using DoorLockSetPinOrIdStatus             = EmberAfDoorLockSetPinOrIdStatus;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for DoorLockUserStatus
+enum class DoorLockUserStatus : uint8_t
+{
+    DOOR_LOCK_USER_STATUS_AVAILABLE         = 0x00,
+    DOOR_LOCK_USER_STATUS_OCCUPIED_ENABLED  = 0x01,
+    DOOR_LOCK_USER_STATUS_OCCUPIED_DISABLED = 0x03,
+    DOOR_LOCK_USER_STATUS_NOT_SUPPORTED     = 0xFF,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using DoorLockUserStatus                   = EmberAfDoorLockUserStatus;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for DoorLockUserType
+enum class DoorLockUserType : uint8_t
+{
+    DOOR_LOCK_USER_TYPE_UNRESTRICTED           = 0x00,
+    DOOR_LOCK_USER_TYPE_YEAR_DAY_SCHEDULE_USER = 0x01,
+    DOOR_LOCK_USER_TYPE_WEEK_DAY_SCHEDULE_USER = 0x02,
+    DOOR_LOCK_USER_TYPE_MASTER_USER            = 0x03,
+    DOOR_LOCK_USER_TYPE_NON_ACCESS_USER        = 0x04,
+    DOOR_LOCK_USER_TYPE_NOT_SUPPORTED          = 0xFF,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using DoorLockUserType                     = EmberAfDoorLockUserType;
+#endif
+
+namespace Commands {
+namespace LockDoor {
 enum class Fields
 {
-    kScheduleId = 0,
-    kUserId     = 1,
+    kPin = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearWeekdaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return LockDoor::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
+    chip::ByteSpan pin;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6728,15 +9241,14 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearWeekdaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return LockDoor::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
+    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearWeekdaySchedule
-namespace ClearWeekdayScheduleResponse {
+}; // namespace LockDoor
+namespace LockDoorResponse {
 enum class Fields
 {
     kStatus = 0,
@@ -6746,7 +9258,7 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearWeekdayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return LockDoorResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
@@ -6757,33 +9269,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearWeekdayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return LockDoorResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearWeekdayScheduleResponse
-namespace SetYeardaySchedule {
+}; // namespace LockDoorResponse
+namespace UnlockDoor {
 enum class Fields
 {
-    kScheduleId     = 0,
-    kUserId         = 1,
-    kLocalStartTime = 2,
-    kLocalEndTime   = 3,
+    kPin = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetYeardaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return UnlockDoor::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
-    uint32_t localStartTime;
-    uint32_t localEndTime;
+    chip::ByteSpan pin;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6791,17 +9297,14 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetYeardaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return UnlockDoor::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
-    uint32_t localStartTime;
-    uint32_t localEndTime;
+    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetYeardaySchedule
-namespace SetYeardayScheduleResponse {
+}; // namespace UnlockDoor
+namespace UnlockDoorResponse {
 enum class Fields
 {
     kStatus = 0,
@@ -6811,7 +9314,7 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetYeardayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return UnlockDoorResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
@@ -6822,29 +9325,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetYeardayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return UnlockDoorResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetYeardayScheduleResponse
-namespace GetYeardaySchedule {
+}; // namespace UnlockDoorResponse
+namespace Toggle {
 enum class Fields
 {
-    kScheduleId = 0,
-    kUserId     = 1,
+    kPin = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetYeardaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return Toggle::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
+    Span<const char> pin;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6852,36 +9353,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetYeardaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return Toggle::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
+    Span<const char> pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetYeardaySchedule
-namespace GetYeardayScheduleResponse {
+}; // namespace Toggle
+namespace ToggleResponse {
 enum class Fields
 {
-    kScheduleId     = 0,
-    kUserId         = 1,
-    kStatus         = 2,
-    kLocalStartTime = 3,
-    kLocalEndTime   = 4,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetYeardayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return ToggleResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
     uint8_t status;
-    uint32_t localStartTime;
-    uint32_t localEndTime;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6889,33 +9381,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetYeardayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return ToggleResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
     uint8_t status;
-    uint32_t localStartTime;
-    uint32_t localEndTime;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetYeardayScheduleResponse
-namespace ClearYeardaySchedule {
+}; // namespace ToggleResponse
+namespace UnlockWithTimeout {
 enum class Fields
 {
-    kScheduleId = 0,
-    kUserId     = 1,
+    kTimeoutInSeconds = 0,
+    kPin              = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearYeardaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return UnlockWithTimeout::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
+    uint16_t timeoutInSeconds;
+    chip::ByteSpan pin;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6923,15 +9411,15 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearYeardaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return UnlockWithTimeout::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint16_t userId;
+    uint16_t timeoutInSeconds;
+    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearYeardaySchedule
-namespace ClearYeardayScheduleResponse {
+}; // namespace UnlockWithTimeout
+namespace UnlockWithTimeoutResponse {
 enum class Fields
 {
     kStatus = 0,
@@ -6941,7 +9429,7 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearYeardayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return UnlockWithTimeoutResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
@@ -6952,33 +9440,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearYeardayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return UnlockWithTimeoutResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearYeardayScheduleResponse
-namespace SetHolidaySchedule {
+}; // namespace UnlockWithTimeoutResponse
+namespace GetLogRecord {
 enum class Fields
 {
-    kScheduleId                 = 0,
-    kLocalStartTime             = 1,
-    kLocalEndTime               = 2,
-    kOperatingModeDuringHoliday = 3,
+    kLogIndex = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetHolidaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return GetLogRecord::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint32_t localStartTime;
-    uint32_t localEndTime;
-    uint8_t operatingModeDuringHoliday;
+    uint16_t logIndex;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -6986,30 +9468,39 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetHolidaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return GetLogRecord::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint32_t localStartTime;
-    uint32_t localEndTime;
-    uint8_t operatingModeDuringHoliday;
+    uint16_t logIndex;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetHolidaySchedule
-namespace SetHolidayScheduleResponse {
+}; // namespace GetLogRecord
+namespace GetLogRecordResponse {
 enum class Fields
 {
-    kStatus = 0,
+    kLogEntryId         = 0,
+    kTimestamp          = 1,
+    kEventType          = 2,
+    kSource             = 3,
+    kEventIdOrAlarmCode = 4,
+    kUserId             = 5,
+    kPin                = 6,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetHolidayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return GetLogRecordResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t status;
+    uint16_t logEntryId;
+    uint32_t timestamp;
+    uint8_t eventType;
+    uint8_t source;
+    uint8_t eventIdOrAlarmCode;
+    uint16_t userId;
+    chip::ByteSpan pin;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7017,27 +9508,39 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetHolidayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return GetLogRecordResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t status;
+    uint16_t logEntryId;
+    uint32_t timestamp;
+    uint8_t eventType;
+    uint8_t source;
+    uint8_t eventIdOrAlarmCode;
+    uint16_t userId;
+    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetHolidayScheduleResponse
-namespace GetHolidaySchedule {
+}; // namespace GetLogRecordResponse
+namespace SetPin {
 enum class Fields
 {
-    kScheduleId = 0,
+    kUserId     = 0,
+    kUserStatus = 1,
+    kUserType   = 2,
+    kPin        = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetHolidaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return SetPin::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    chip::ByteSpan pin;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7045,35 +9548,30 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetHolidaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return SetPin::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetHolidaySchedule
-namespace GetHolidayScheduleResponse {
+}; // namespace SetPin
+namespace SetPinResponse {
 enum class Fields
 {
-    kScheduleId                 = 0,
-    kStatus                     = 1,
-    kLocalStartTime             = 2,
-    kLocalEndTime               = 3,
-    kOperatingModeDuringHoliday = 4,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetHolidayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return SetPinResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint8_t status;
-    uint32_t localStartTime;
-    uint32_t localEndTime;
-    uint8_t operatingModeDuringHoliday;
+    DoorLockSetPinOrIdStatus status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7081,31 +9579,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetHolidayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return SetPinResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
-    uint8_t status;
-    uint32_t localStartTime;
-    uint32_t localEndTime;
-    uint8_t operatingModeDuringHoliday;
+    DoorLockSetPinOrIdStatus status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetHolidayScheduleResponse
-namespace ClearHolidaySchedule {
+}; // namespace SetPinResponse
+namespace GetPin {
 enum class Fields
 {
-    kScheduleId = 0,
+    kUserId = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearHolidaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return GetPin::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
+    uint16_t userId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7113,27 +9607,33 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearHolidaySchedule::Id; }
+    static constexpr CommandId GetCommandId() { return GetPin::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t scheduleId;
+    uint16_t userId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearHolidaySchedule
-namespace ClearHolidayScheduleResponse {
+}; // namespace GetPin
+namespace GetPinResponse {
 enum class Fields
 {
-    kStatus = 0,
+    kUserId     = 0,
+    kUserStatus = 1,
+    kUserType   = 2,
+    kPin        = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearHolidayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return GetPinResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t status;
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    chip::ByteSpan pin;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7141,29 +9641,30 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearHolidayScheduleResponse::Id; }
+    static constexpr CommandId GetCommandId() { return GetPinResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t status;
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    chip::ByteSpan pin;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearHolidayScheduleResponse
-namespace SetUserType {
+}; // namespace GetPinResponse
+namespace ClearPin {
 enum class Fields
 {
-    kUserId   = 0,
-    kUserType = 1,
+    kUserId = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetUserType::Id; }
+    static constexpr CommandId GetCommandId() { return ClearPin::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint16_t userId;
-    DoorLockUserType userType;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7171,15 +9672,14 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetUserType::Id; }
+    static constexpr CommandId GetCommandId() { return ClearPin::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint16_t userId;
-    DoorLockUserType userType;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetUserType
-namespace SetUserTypeResponse {
+}; // namespace ClearPin
+namespace ClearPinResponse {
 enum class Fields
 {
     kStatus = 0,
@@ -7189,7 +9689,7 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetUserTypeResponse::Id; }
+    static constexpr CommandId GetCommandId() { return ClearPinResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
@@ -7200,57 +9700,51 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetUserTypeResponse::Id; }
+    static constexpr CommandId GetCommandId() { return ClearPinResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetUserTypeResponse
-namespace GetUserType {
+}; // namespace ClearPinResponse
+namespace ClearAllPins {
 enum class Fields
 {
-    kUserId = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetUserType::Id; }
+    static constexpr CommandId GetCommandId() { return ClearAllPins::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t userId;
-
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
 
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetUserType::Id; }
+    static constexpr CommandId GetCommandId() { return ClearAllPins::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t userId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetUserType
-namespace GetUserTypeResponse {
+}; // namespace ClearAllPins
+namespace ClearAllPinsResponse {
 enum class Fields
 {
-    kUserId   = 0,
-    kUserType = 1,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetUserTypeResponse::Id; }
+    static constexpr CommandId GetCommandId() { return ClearAllPinsResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t userId;
-    DoorLockUserType userType;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7258,34 +9752,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetUserTypeResponse::Id; }
+    static constexpr CommandId GetCommandId() { return ClearAllPinsResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t userId;
-    DoorLockUserType userType;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetUserTypeResponse
-namespace SetRfid {
+}; // namespace ClearAllPinsResponse
+namespace SetUserStatus {
 enum class Fields
 {
     kUserId     = 0,
     kUserStatus = 1,
-    kUserType   = 2,
-    kId         = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetRfid::Id; }
+    static constexpr CommandId GetCommandId() { return SetUserStatus::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint16_t userId;
-    DoorLockUserStatus userStatus;
-    DoorLockUserType userType;
-    chip::ByteSpan id;
+    uint8_t userStatus;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7293,17 +9782,15 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetRfid::Id; }
+    static constexpr CommandId GetCommandId() { return SetUserStatus::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint16_t userId;
-    DoorLockUserStatus userStatus;
-    DoorLockUserType userType;
-    chip::ByteSpan id;
+    uint8_t userStatus;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetRfid
-namespace SetRfidResponse {
+}; // namespace SetUserStatus
+namespace SetUserStatusResponse {
 enum class Fields
 {
     kStatus = 0,
@@ -7313,10 +9800,10 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetRfidResponse::Id; }
+    static constexpr CommandId GetCommandId() { return SetUserStatusResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    DoorLockSetPinOrIdStatus status;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7324,14 +9811,14 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetRfidResponse::Id; }
+    static constexpr CommandId GetCommandId() { return SetUserStatusResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    DoorLockSetPinOrIdStatus status;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetRfidResponse
-namespace GetRfid {
+}; // namespace SetUserStatusResponse
+namespace GetUserStatus {
 enum class Fields
 {
     kUserId = 0,
@@ -7341,7 +9828,7 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetRfid::Id; }
+    static constexpr CommandId GetCommandId() { return GetUserStatus::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint16_t userId;
@@ -7352,33 +9839,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetRfid::Id; }
+    static constexpr CommandId GetCommandId() { return GetUserStatus::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint16_t userId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetRfid
-namespace GetRfidResponse {
+}; // namespace GetUserStatus
+namespace GetUserStatusResponse {
 enum class Fields
 {
-    kUserId     = 0,
-    kUserStatus = 1,
-    kUserType   = 2,
-    kRfid       = 3,
+    kUserId = 0,
+    kStatus = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetRfidResponse::Id; }
+    static constexpr CommandId GetCommandId() { return GetUserStatusResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint16_t userId;
-    DoorLockUserStatus userStatus;
-    DoorLockUserType userType;
-    chip::ByteSpan rfid;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7386,30 +9869,40 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetRfidResponse::Id; }
+    static constexpr CommandId GetCommandId() { return GetUserStatusResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint16_t userId;
-    DoorLockUserStatus userStatus;
-    DoorLockUserType userType;
-    chip::ByteSpan rfid;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetRfidResponse
-namespace ClearRfid {
+}; // namespace GetUserStatusResponse
+namespace SetWeekdaySchedule {
 enum class Fields
 {
-    kUserId = 0,
+    kScheduleId  = 0,
+    kUserId      = 1,
+    kDaysMask    = 2,
+    kStartHour   = 3,
+    kStartMinute = 4,
+    kEndHour     = 5,
+    kEndMinute   = 6,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearRfid::Id; }
+    static constexpr CommandId GetCommandId() { return SetWeekdaySchedule::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
     uint16_t userId;
+    uint8_t daysMask;
+    uint8_t startHour;
+    uint8_t startMinute;
+    uint8_t endHour;
+    uint8_t endMinute;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7417,14 +9910,20 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearRfid::Id; }
+    static constexpr CommandId GetCommandId() { return SetWeekdaySchedule::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
     uint16_t userId;
+    uint8_t daysMask;
+    uint8_t startHour;
+    uint8_t startMinute;
+    uint8_t endHour;
+    uint8_t endMinute;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearRfid
-namespace ClearRfidResponse {
+}; // namespace SetWeekdaySchedule
+namespace SetWeekdayScheduleResponse {
 enum class Fields
 {
     kStatus = 0,
@@ -7434,7 +9933,7 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearRfidResponse::Id; }
+    static constexpr CommandId GetCommandId() { return SetWeekdayScheduleResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
@@ -7445,51 +9944,72 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearRfidResponse::Id; }
+    static constexpr CommandId GetCommandId() { return SetWeekdayScheduleResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearRfidResponse
-namespace ClearAllRfids {
+}; // namespace SetWeekdayScheduleResponse
+namespace GetWeekdaySchedule {
 enum class Fields
 {
+    kScheduleId = 0,
+    kUserId     = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearAllRfids::Id; }
+    static constexpr CommandId GetCommandId() { return GetWeekdaySchedule::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint16_t userId;
+
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
 
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearAllRfids::Id; }
+    static constexpr CommandId GetCommandId() { return GetWeekdaySchedule::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint16_t userId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearAllRfids
-namespace ClearAllRfidsResponse {
+}; // namespace GetWeekdaySchedule
+namespace GetWeekdayScheduleResponse {
 enum class Fields
 {
-    kStatus = 0,
+    kScheduleId  = 0,
+    kUserId      = 1,
+    kStatus      = 2,
+    kDaysMask    = 3,
+    kStartHour   = 4,
+    kStartMinute = 5,
+    kEndHour     = 6,
+    kEndMinute   = 7,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearAllRfidsResponse::Id; }
+    static constexpr CommandId GetCommandId() { return GetWeekdayScheduleResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint16_t userId;
     uint8_t status;
+    uint8_t daysMask;
+    uint8_t startHour;
+    uint8_t startMinute;
+    uint8_t endHour;
+    uint8_t endMinute;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7497,37 +10017,36 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearAllRfidsResponse::Id; }
+    static constexpr CommandId GetCommandId() { return GetWeekdayScheduleResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint16_t userId;
     uint8_t status;
+    uint8_t daysMask;
+    uint8_t startHour;
+    uint8_t startMinute;
+    uint8_t endHour;
+    uint8_t endMinute;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearAllRfidsResponse
-namespace OperationEventNotification {
+}; // namespace GetWeekdayScheduleResponse
+namespace ClearWeekdaySchedule {
 enum class Fields
 {
-    kSource    = 0,
-    kEventCode = 1,
-    kUserId    = 2,
-    kPin       = 3,
-    kTimeStamp = 4,
-    kData      = 5,
+    kScheduleId = 0,
+    kUserId     = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return OperationEventNotification::Id; }
+    static constexpr CommandId GetCommandId() { return ClearWeekdaySchedule::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t source;
-    DoorLockOperationEventCode eventCode;
+    uint8_t scheduleId;
     uint16_t userId;
-    chip::ByteSpan pin;
-    uint32_t timeStamp;
-    Span<const char> data;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7535,46 +10054,28 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return OperationEventNotification::Id; }
+    static constexpr CommandId GetCommandId() { return ClearWeekdaySchedule::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t source;
-    DoorLockOperationEventCode eventCode;
+    uint8_t scheduleId;
     uint16_t userId;
-    chip::ByteSpan pin;
-    uint32_t timeStamp;
-    Span<const char> data;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace OperationEventNotification
-namespace ProgrammingEventNotification {
+}; // namespace ClearWeekdaySchedule
+namespace ClearWeekdayScheduleResponse {
 enum class Fields
 {
-    kSource     = 0,
-    kEventCode  = 1,
-    kUserId     = 2,
-    kPin        = 3,
-    kUserType   = 4,
-    kUserStatus = 5,
-    kTimeStamp  = 6,
-    kData       = 7,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ProgrammingEventNotification::Id; }
+    static constexpr CommandId GetCommandId() { return ClearWeekdayScheduleResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t source;
-    DoorLockProgrammingEventCode eventCode;
-    uint16_t userId;
-    chip::ByteSpan pin;
-    DoorLockUserType userType;
-    DoorLockUserStatus userStatus;
-    uint32_t timeStamp;
-    Span<const char> data;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7582,92 +10083,64 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ProgrammingEventNotification::Id; }
+    static constexpr CommandId GetCommandId() { return ClearWeekdayScheduleResponse::Id; }
     static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t source;
-    DoorLockProgrammingEventCode eventCode;
-    uint16_t userId;
-    chip::ByteSpan pin;
-    DoorLockUserType userType;
-    DoorLockUserStatus userStatus;
-    uint32_t timeStamp;
-    Span<const char> data;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ProgrammingEventNotification
-} // namespace Commands
-} // namespace DoorLock
-namespace WindowCovering {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for WcEndProductType
-enum class WcEndProductType : uint8_t
+}; // namespace ClearWeekdayScheduleResponse
+namespace SetYeardaySchedule {
+enum class Fields
 {
-    WC_END_PRODUCT_TYPE_ROLLER_SHADE                 = 0x00,
-    WC_END_PRODUCT_TYPE_ROMAN_SHADE                  = 0x01,
-    WC_END_PRODUCT_TYPE_BALLOON_SHADE                = 0x02,
-    WC_END_PRODUCT_TYPE_WOVEN_WOOD                   = 0x03,
-    WC_END_PRODUCT_TYPE_PLEATED_SHADE                = 0x04,
-    WC_END_PRODUCT_TYPE_CELLULAR_SHADE               = 0x05,
-    WC_END_PRODUCT_TYPE_LAYERED_SHADE                = 0x06,
-    WC_END_PRODUCT_TYPE_LAYERED_SHADE2_D             = 0x07,
-    WC_END_PRODUCT_TYPE_SHEER_SHADE                  = 0x08,
-    WC_END_PRODUCT_TYPE_TILT_ONLY_INTERIOR_BLIND     = 0x09,
-    WC_END_PRODUCT_TYPE_INTERIOR_BLIND               = 0x0A,
-    WC_END_PRODUCT_TYPE_VERTICAL_BLIND_STRIP_CURTAIN = 0x0B,
-    WC_END_PRODUCT_TYPE_INTERIOR_VENETIAN_BLIND      = 0x0C,
-    WC_END_PRODUCT_TYPE_EXTERIOR_VENETIAN_BLIND      = 0x0D,
-    WC_END_PRODUCT_TYPE_LATERAL_LEFT_CURTAIN         = 0x0E,
-    WC_END_PRODUCT_TYPE_LATERAL_RIGHT_CURTAIN        = 0x0F,
-    WC_END_PRODUCT_TYPE_CENTRAL_CURTAIN              = 0x10,
-    WC_END_PRODUCT_TYPE_ROLLER_SHUTTER               = 0x11,
-    WC_END_PRODUCT_TYPE_EXTERIOR_VERTICAL_SCREEN     = 0x12,
-    WC_END_PRODUCT_TYPE_AWNING_TERRACE_PATIO         = 0x13,
-    WC_END_PRODUCT_TYPE_AWNING_VERTICAL_SCREEN       = 0x14,
-    WC_END_PRODUCT_TYPE_TILT_ONLY_PERGOLA            = 0x15,
-    WC_END_PRODUCT_TYPE_SWINGING_SHUTTER             = 0x16,
-    WC_END_PRODUCT_TYPE_SLIDING_SHUTTER              = 0x17,
-    WC_END_PRODUCT_TYPE_UNKNOWN                      = 0xFF,
+    kScheduleId     = 0,
+    kUserId         = 1,
+    kLocalStartTime = 2,
+    kLocalEndTime   = 3,
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using WcEndProductType                     = EmberAfWcEndProductType;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for WcType
-enum class WcType : uint8_t
+
+struct Type
 {
-    WC_TYPE_ROLLERSHADE                 = 0x00,
-    WC_TYPE_ROLLERSHADE2_MOTOR          = 0x01,
-    WC_TYPE_ROLLERSHADE_EXTERIOR        = 0x02,
-    WC_TYPE_ROLLERSHADE_EXTERIOR2_MOTOR = 0x03,
-    WC_TYPE_DRAPERY                     = 0x04,
-    WC_TYPE_AWNING                      = 0x05,
-    WC_TYPE_SHUTTER                     = 0x06,
-    WC_TYPE_TILT_BLIND_TILT_ONLY        = 0x07,
-    WC_TYPE_TILT_BLIND_LIFT_AND_TILT    = 0x08,
-    WC_TYPE_PROJECTOR_SCREEN            = 0x09,
-    WC_TYPE_UNKNOWN                     = 0xFF,
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SetYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using WcType                               = EmberAfWcType;
-#endif
 
-namespace Commands {
-namespace UpOrOpen {
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SetYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetYeardaySchedule
+namespace SetYeardayScheduleResponse {
 enum class Fields
 {
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return UpOrOpen::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return SetYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7675,23 +10148,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return UpOrOpen::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return SetYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace UpOrOpen
-namespace DownOrClose {
+}; // namespace SetYeardayScheduleResponse
+namespace GetYeardaySchedule {
 enum class Fields
 {
+    kScheduleId = 0,
+    kUserId     = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return DownOrClose::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return GetYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7699,23 +10178,36 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return DownOrClose::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return GetYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint16_t userId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace DownOrClose
-namespace StopMotion {
+}; // namespace GetYeardaySchedule
+namespace GetYeardayScheduleResponse {
 enum class Fields
 {
+    kScheduleId     = 0,
+    kUserId         = 1,
+    kStatus         = 2,
+    kLocalStartTime = 3,
+    kLocalEndTime   = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StopMotion::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return GetYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
+    uint8_t status;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7723,26 +10215,33 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return StopMotion::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return GetYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint16_t userId;
+    uint8_t status;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace StopMotion
-namespace GoToLiftValue {
+}; // namespace GetYeardayScheduleResponse
+namespace ClearYeardaySchedule {
 enum class Fields
 {
-    kLiftValue = 0,
+    kScheduleId = 0,
+    kUserId     = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GoToLiftValue::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return ClearYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t liftValue;
+    uint8_t scheduleId;
+    uint16_t userId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7750,29 +10249,28 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GoToLiftValue::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return ClearYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t liftValue;
+    uint8_t scheduleId;
+    uint16_t userId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GoToLiftValue
-namespace GoToLiftPercentage {
+}; // namespace ClearYeardaySchedule
+namespace ClearYeardayScheduleResponse {
 enum class Fields
 {
-    kLiftPercentageValue    = 0,
-    kLiftPercent100thsValue = 1,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GoToLiftPercentage::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return ClearYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t liftPercentageValue;
-    uint16_t liftPercent100thsValue;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7780,28 +10278,33 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GoToLiftPercentage::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return ClearYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t liftPercentageValue;
-    uint16_t liftPercent100thsValue;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GoToLiftPercentage
-namespace GoToTiltValue {
+}; // namespace ClearYeardayScheduleResponse
+namespace SetHolidaySchedule {
 enum class Fields
 {
-    kTiltValue = 0,
+    kScheduleId                 = 0,
+    kLocalStartTime             = 1,
+    kLocalEndTime               = 2,
+    kOperatingModeDuringHoliday = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GoToTiltValue::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return SetHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t tiltValue;
+    uint8_t scheduleId;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+    uint8_t operatingModeDuringHoliday;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7809,29 +10312,30 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GoToTiltValue::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return SetHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t tiltValue;
+    uint8_t scheduleId;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+    uint8_t operatingModeDuringHoliday;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GoToTiltValue
-namespace GoToTiltPercentage {
+}; // namespace SetHolidaySchedule
+namespace SetHolidayScheduleResponse {
 enum class Fields
 {
-    kTiltPercentageValue    = 0,
-    kTiltPercent100thsValue = 1,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GoToTiltPercentage::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return SetHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t tiltPercentageValue;
-    uint16_t tiltPercent100thsValue;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7839,33 +10343,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GoToTiltPercentage::Id; }
-    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr CommandId GetCommandId() { return SetHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t tiltPercentageValue;
-    uint16_t tiltPercent100thsValue;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GoToTiltPercentage
-} // namespace Commands
-} // namespace WindowCovering
-namespace BarrierControl {
-
-namespace Commands {
-namespace BarrierControlGoToPercent {
+}; // namespace SetHolidayScheduleResponse
+namespace GetHolidaySchedule {
 enum class Fields
 {
-    kPercentOpen = 0,
+    kScheduleId = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return BarrierControlGoToPercent::Id; }
-    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr CommandId GetCommandId() { return GetHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t percentOpen;
+    uint8_t scheduleId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7873,24 +10371,35 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return BarrierControlGoToPercent::Id; }
-    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr CommandId GetCommandId() { return GetHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t percentOpen;
+    uint8_t scheduleId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace BarrierControlGoToPercent
-namespace BarrierControlStop {
+}; // namespace GetHolidaySchedule
+namespace GetHolidayScheduleResponse {
 enum class Fields
 {
+    kScheduleId                 = 0,
+    kStatus                     = 1,
+    kLocalStartTime             = 2,
+    kLocalEndTime               = 3,
+    kOperatingModeDuringHoliday = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return BarrierControlStop::Id; }
-    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr CommandId GetCommandId() { return GetHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint8_t status;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+    uint8_t operatingModeDuringHoliday;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7898,79 +10407,59 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return BarrierControlStop::Id; }
-    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr CommandId GetCommandId() { return GetHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint8_t status;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+    uint8_t operatingModeDuringHoliday;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace BarrierControlStop
-} // namespace Commands
-} // namespace BarrierControl
-namespace PumpConfigurationAndControl {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for PumpControlMode
-enum class PumpControlMode : uint8_t
+}; // namespace GetHolidayScheduleResponse
+namespace ClearHolidaySchedule {
+enum class Fields
 {
-    PUMP_CONTROL_MODE_CONSTANT_SPEED        = 0x00,
-    PUMP_CONTROL_MODE_CONSTANT_PRESSURE     = 0x01,
-    PUMP_CONTROL_MODE_PROPORTIONAL_PRESSURE = 0x02,
-    PUMP_CONTROL_MODE_CONSTANT_FLOW         = 0x03,
-    PUMP_CONTROL_MODE_CONSTANT_TEMPERATURE  = 0x05,
-    PUMP_CONTROL_MODE_AUTOMATIC             = 0x07,
+    kScheduleId = 0,
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using PumpControlMode                      = EmberAfPumpControlMode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for PumpOperationMode
-enum class PumpOperationMode : uint8_t
+
+struct Type
 {
-    PUMP_OPERATION_MODE_NORMAL  = 0x00,
-    PUMP_OPERATION_MODE_MINIMUM = 0x01,
-    PUMP_OPERATION_MODE_MAXIMUM = 0x02,
-    PUMP_OPERATION_MODE_LOCAL   = 0x03,
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ClearHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using PumpOperationMode                    = EmberAfPumpOperationMode;
-#endif
 
-} // namespace PumpConfigurationAndControl
-namespace Thermostat {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for SetpointAdjustMode
-enum class SetpointAdjustMode : uint8_t
+struct DecodableType
 {
-    SETPOINT_ADJUST_MODE_HEAT_SETPOINT           = 0x00,
-    SETPOINT_ADJUST_MODE_COOL_SETPOINT           = 0x01,
-    SETPOINT_ADJUST_MODE_HEAT_AND_COOL_SETPOINTS = 0x02,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using SetpointAdjustMode                   = EmberAfSetpointAdjustMode;
-#endif
+public:
+    static constexpr CommandId GetCommandId() { return ClearHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-namespace Commands {
-namespace SetpointRaiseLower {
+    uint8_t scheduleId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearHolidaySchedule
+namespace ClearHolidayScheduleResponse {
 enum class Fields
 {
-    kMode   = 0,
-    kAmount = 1,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetpointRaiseLower::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return ClearHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    SetpointAdjustMode mode;
-    int8_t amount;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -7978,34 +10467,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetpointRaiseLower::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return ClearHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    SetpointAdjustMode mode;
-    int8_t amount;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetpointRaiseLower
-namespace CurrentWeeklySchedule {
+}; // namespace ClearHolidayScheduleResponse
+namespace SetUserType {
 enum class Fields
 {
-    kNumberOfTransitionsForSequence = 0,
-    kDayOfWeekForSequence           = 1,
-    kModeForSequence                = 2,
-    kPayload                        = 3,
+    kUserId   = 0,
+    kUserType = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return CurrentWeeklySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return SetUserType::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t numberOfTransitionsForSequence;
-    uint8_t dayOfWeekForSequence;
-    uint8_t modeForSequence;
-    DataModel::List<uint8_t> payload;
+    uint16_t userId;
+    DoorLockUserType userType;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8013,36 +10497,28 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return CurrentWeeklySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return SetUserType::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t numberOfTransitionsForSequence;
-    uint8_t dayOfWeekForSequence;
-    uint8_t modeForSequence;
-    DataModel::DecodableList<uint8_t> payload;
+    uint16_t userId;
+    DoorLockUserType userType;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace CurrentWeeklySchedule
-namespace SetWeeklySchedule {
+}; // namespace SetUserType
+namespace SetUserTypeResponse {
 enum class Fields
 {
-    kNumberOfTransitionsForSequence = 0,
-    kDayOfWeekForSequence           = 1,
-    kModeForSequence                = 2,
-    kPayload                        = 3,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetWeeklySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return SetUserTypeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t numberOfTransitionsForSequence;
-    uint8_t dayOfWeekForSequence;
-    uint8_t modeForSequence;
-    DataModel::List<uint8_t> payload;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8050,40 +10526,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SetWeeklySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return SetUserTypeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t numberOfTransitionsForSequence;
-    uint8_t dayOfWeekForSequence;
-    uint8_t modeForSequence;
-    DataModel::DecodableList<uint8_t> payload;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SetWeeklySchedule
-namespace RelayStatusLog {
+}; // namespace SetUserTypeResponse
+namespace GetUserType {
 enum class Fields
 {
-    kTimeOfDay            = 0,
-    kRelayStatus          = 1,
-    kLocalTemperature     = 2,
-    kHumidityInPercentage = 3,
-    kSetpoint             = 4,
-    kUnreadEntries        = 5,
+    kUserId = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return RelayStatusLog::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return GetUserType::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t timeOfDay;
-    uint16_t relayStatus;
-    int16_t localTemperature;
-    uint8_t humidityInPercentage;
-    int16_t setpoint;
-    uint16_t unreadEntries;
+    uint16_t userId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8091,34 +10554,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return RelayStatusLog::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return GetUserType::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint16_t timeOfDay;
-    uint16_t relayStatus;
-    int16_t localTemperature;
-    uint8_t humidityInPercentage;
-    int16_t setpoint;
-    uint16_t unreadEntries;
+    uint16_t userId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace RelayStatusLog
-namespace GetWeeklySchedule {
+}; // namespace GetUserType
+namespace GetUserTypeResponse {
 enum class Fields
 {
-    kDaysToReturn = 0,
-    kModeToReturn = 1,
+    kUserId   = 0,
+    kUserType = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetWeeklySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return GetUserTypeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t daysToReturn;
-    uint8_t modeToReturn;
+    uint16_t userId;
+    DoorLockUserType userType;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8126,25 +10584,34 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetWeeklySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return GetUserTypeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t daysToReturn;
-    uint8_t modeToReturn;
+    uint16_t userId;
+    DoorLockUserType userType;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetWeeklySchedule
-namespace ClearWeeklySchedule {
+}; // namespace GetUserTypeResponse
+namespace SetRfid {
 enum class Fields
 {
+    kUserId     = 0,
+    kUserStatus = 1,
+    kUserType   = 2,
+    kId         = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ClearWeeklySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return SetRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    chip::ByteSpan id;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8152,23 +10619,30 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ClearWeeklySchedule::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return SetRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    chip::ByteSpan id;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ClearWeeklySchedule
-namespace GetRelayStatusLog {
+}; // namespace SetRfid
+namespace SetRfidResponse {
 enum class Fields
 {
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetRelayStatusLog::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return SetRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    DoorLockSetPinOrIdStatus status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8176,150 +10650,61 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetRelayStatusLog::Id; }
-    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr CommandId GetCommandId() { return SetRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    DoorLockSetPinOrIdStatus status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetRelayStatusLog
-} // namespace Commands
-} // namespace Thermostat
-namespace FanControl {
+}; // namespace SetRfidResponse
+namespace GetRfid {
+enum class Fields
+{
+    kUserId = 0,
+};
 
-} // namespace FanControl
-namespace DehumidificationControl {
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-} // namespace DehumidificationControl
-namespace ThermostatUserInterfaceConfiguration {
+    uint16_t userId;
 
-} // namespace ThermostatUserInterfaceConfiguration
-namespace ColorControl {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ColorLoopAction
-enum class ColorLoopAction : uint8_t
-{
-    COLOR_LOOP_ACTION_DEACTIVATE                                  = 0x00,
-    COLOR_LOOP_ACTION_ACTIVATE_FROM_COLOR_LOOP_START_ENHANCED_HUE = 0x01,
-    COLOR_LOOP_ACTION_ACTIVATE_FROM_ENHANCED_CURRENT_HUE          = 0x02,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ColorLoopAction                      = EmberAfColorLoopAction;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ColorLoopDirection
-enum class ColorLoopDirection : uint8_t
-{
-    COLOR_LOOP_DIRECTION_DECREMENT_HUE = 0x00,
-    COLOR_LOOP_DIRECTION_INCREMENT_HUE = 0x01,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ColorLoopDirection                   = EmberAfColorLoopDirection;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ColorMode
-enum class ColorMode : uint8_t
-{
-    COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION = 0x00,
-    COLOR_MODE_CURRENT_X_AND_CURRENT_Y            = 0x01,
-    COLOR_MODE_COLOR_TEMPERATURE                  = 0x02,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ColorMode                            = EmberAfColorMode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for HueDirection
-enum class HueDirection : uint8_t
-{
-    HUE_DIRECTION_SHORTEST_DISTANCE = 0x00,
-    HUE_DIRECTION_LONGEST_DISTANCE  = 0x01,
-    HUE_DIRECTION_UP                = 0x02,
-    HUE_DIRECTION_DOWN              = 0x03,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using HueDirection                         = EmberAfHueDirection;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for HueMoveMode
-enum class HueMoveMode : uint8_t
-{
-    HUE_MOVE_MODE_STOP = 0x00,
-    HUE_MOVE_MODE_UP   = 0x01,
-    HUE_MOVE_MODE_DOWN = 0x03,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using HueMoveMode                          = EmberAfHueMoveMode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for HueStepMode
-enum class HueStepMode : uint8_t
-{
-    HUE_STEP_MODE_UP   = 0x01,
-    HUE_STEP_MODE_DOWN = 0x03,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using HueStepMode                          = EmberAfHueStepMode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for SaturationMoveMode
-enum class SaturationMoveMode : uint8_t
-{
-    SATURATION_MOVE_MODE_STOP = 0x00,
-    SATURATION_MOVE_MODE_UP   = 0x01,
-    SATURATION_MOVE_MODE_DOWN = 0x03,
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using SaturationMoveMode                   = EmberAfSaturationMoveMode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for SaturationStepMode
-enum class SaturationStepMode : uint8_t
+
+struct DecodableType
 {
-    SATURATION_STEP_MODE_UP   = 0x01,
-    SATURATION_STEP_MODE_DOWN = 0x03,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using SaturationStepMode                   = EmberAfSaturationStepMode;
-#endif
+public:
+    static constexpr CommandId GetCommandId() { return GetRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-namespace Commands {
-namespace MoveToHue {
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetRfid
+namespace GetRfidResponse {
 enum class Fields
 {
-    kHue             = 0,
-    kDirection       = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
+    kUserId     = 0,
+    kUserStatus = 1,
+    kUserType   = 2,
+    kRfid       = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveToHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return GetRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t hue;
-    HueDirection direction;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    chip::ByteSpan rfid;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8327,37 +10712,30 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MoveToHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return GetRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t hue;
-    HueDirection direction;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    chip::ByteSpan rfid;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MoveToHue
-namespace MoveHue {
+}; // namespace GetRfidResponse
+namespace ClearRfid {
 enum class Fields
 {
-    kMoveMode        = 0,
-    kRate            = 1,
-    kOptionsMask     = 2,
-    kOptionsOverride = 3,
+    kUserId = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ClearRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    HueMoveMode moveMode;
-    uint8_t rate;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint16_t userId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8365,38 +10743,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MoveHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ClearRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    HueMoveMode moveMode;
-    uint8_t rate;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint16_t userId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MoveHue
-namespace StepHue {
+}; // namespace ClearRfid
+namespace ClearRfidResponse {
 enum class Fields
 {
-    kStepMode        = 0,
-    kStepSize        = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StepHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ClearRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    HueStepMode stepMode;
-    uint8_t stepSize;
-    uint8_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8404,37 +10771,24 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return StepHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ClearRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    HueStepMode stepMode;
-    uint8_t stepSize;
-    uint8_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace StepHue
-namespace MoveToSaturation {
+}; // namespace ClearRfidResponse
+namespace ClearAllRfids {
 enum class Fields
 {
-    kSaturation      = 0,
-    kTransitionTime  = 1,
-    kOptionsMask     = 2,
-    kOptionsOverride = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveToSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
-
-    uint8_t saturation;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    static constexpr CommandId GetCommandId() { return ClearAllRfids::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8442,36 +10796,26 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MoveToSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ClearAllRfids::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t saturation;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MoveToSaturation
-namespace MoveSaturation {
+}; // namespace ClearAllRfids
+namespace ClearAllRfidsResponse {
 enum class Fields
 {
-    kMoveMode        = 0,
-    kRate            = 1,
-    kOptionsMask     = 2,
-    kOptionsOverride = 3,
+    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ClearAllRfidsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    SaturationMoveMode moveMode;
-    uint8_t rate;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t status;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8479,38 +10823,37 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MoveSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ClearAllRfidsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    SaturationMoveMode moveMode;
-    uint8_t rate;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t status;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MoveSaturation
-namespace StepSaturation {
+}; // namespace ClearAllRfidsResponse
+namespace OperationEventNotification {
 enum class Fields
 {
-    kStepMode        = 0,
-    kStepSize        = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
+    kSource    = 0,
+    kEventCode = 1,
+    kUserId    = 2,
+    kPin       = 3,
+    kTimeStamp = 4,
+    kData      = 5,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StepSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return OperationEventNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    SaturationStepMode stepMode;
-    uint8_t stepSize;
-    uint8_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t source;
+    DoorLockOperationEventCode eventCode;
+    uint16_t userId;
+    chip::ByteSpan pin;
+    uint32_t timeStamp;
+    Span<const char> data;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8518,39 +10861,46 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return StepSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return OperationEventNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    SaturationStepMode stepMode;
-    uint8_t stepSize;
-    uint8_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t source;
+    DoorLockOperationEventCode eventCode;
+    uint16_t userId;
+    chip::ByteSpan pin;
+    uint32_t timeStamp;
+    Span<const char> data;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace StepSaturation
-namespace MoveToHueAndSaturation {
+}; // namespace OperationEventNotification
+namespace ProgrammingEventNotification {
 enum class Fields
 {
-    kHue             = 0,
-    kSaturation      = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
+    kSource     = 0,
+    kEventCode  = 1,
+    kUserId     = 2,
+    kPin        = 3,
+    kUserType   = 4,
+    kUserStatus = 5,
+    kTimeStamp  = 6,
+    kData       = 7,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveToHueAndSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ProgrammingEventNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t hue;
-    uint8_t saturation;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t source;
+    DoorLockProgrammingEventCode eventCode;
+    uint16_t userId;
+    chip::ByteSpan pin;
+    DoorLockUserType userType;
+    DoorLockUserStatus userStatus;
+    uint32_t timeStamp;
+    Span<const char> data;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8558,270 +10908,525 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MoveToHueAndSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return ProgrammingEventNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
-    uint8_t hue;
-    uint8_t saturation;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t source;
+    DoorLockProgrammingEventCode eventCode;
+    uint16_t userId;
+    chip::ByteSpan pin;
+    DoorLockUserType userType;
+    DoorLockUserStatus userStatus;
+    uint32_t timeStamp;
+    Span<const char> data;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MoveToHueAndSaturation
-namespace MoveToColor {
-enum class Fields
+}; // namespace ProgrammingEventNotification
+} // namespace Commands
+
+namespace Attributes {
+namespace LockState {
+struct TypeInfo
 {
-    kColorX          = 0,
-    kColorY          = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LockState::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace LockState
+namespace LockType {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveToColor::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LockType::Id; }
+};
 
-    uint16_t colorX;
-    uint16_t colorY;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+using DecodableTypeInfo = TypeInfo;
+} // namespace LockType
+namespace ActuatorEnabled {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActuatorEnabled::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActuatorEnabled
+namespace DoorState {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DoorState::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace DoorState
+namespace DoorOpenEvents {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MoveToColor::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DoorOpenEvents::Id; }
+};
 
-    uint16_t colorX;
-    uint16_t colorY;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace DoorOpenEvents
+namespace DoorClosedEvents {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DoorClosedEvents::Id; }
 };
-}; // namespace MoveToColor
-namespace MoveColor {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DoorClosedEvents
+namespace OpenPeriod {
+struct TypeInfo
 {
-    kRateX           = 0,
-    kRateY           = 1,
-    kOptionsMask     = 2,
-    kOptionsOverride = 3,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OpenPeriod::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace OpenPeriod
+namespace NumLockRecordsSupported {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveColor::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumLockRecordsSupported::Id; }
+};
 
-    int16_t rateX;
-    int16_t rateY;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumLockRecordsSupported
+namespace NumTotalUsersSupported {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumTotalUsersSupported::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumTotalUsersSupported
+namespace NumPinUsersSupported {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumPinUsersSupported::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumPinUsersSupported
+namespace NumRfidUsersSupported {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MoveColor::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumRfidUsersSupported::Id; }
+};
 
-    int16_t rateX;
-    int16_t rateY;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumRfidUsersSupported
+namespace NumWeekdaySchedulesSupportedPerUser {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumWeekdaySchedulesSupportedPerUser::Id; }
 };
-}; // namespace MoveColor
-namespace StepColor {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumWeekdaySchedulesSupportedPerUser
+namespace NumYeardaySchedulesSupportedPerUser {
+struct TypeInfo
 {
-    kStepX           = 0,
-    kStepY           = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumYeardaySchedulesSupportedPerUser::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumYeardaySchedulesSupportedPerUser
+namespace NumHolidaySchedulesSupportedPerUser {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StepColor::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumHolidaySchedulesSupportedPerUser::Id; }
+};
 
-    int16_t stepX;
-    int16_t stepY;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumHolidaySchedulesSupportedPerUser
+namespace MaxPinLength {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxPinLength::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxPinLength
+namespace MinPinLength {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinPinLength::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinPinLength
+namespace MaxRfidCodeLength {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return StepColor::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxRfidCodeLength::Id; }
+};
 
-    int16_t stepX;
-    int16_t stepY;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxRfidCodeLength
+namespace MinRfidCodeLength {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinRfidCodeLength::Id; }
 };
-}; // namespace StepColor
-namespace MoveToColorTemperature {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinRfidCodeLength
+namespace EnableLogging {
+struct TypeInfo
 {
-    kColorTemperature = 0,
-    kTransitionTime   = 1,
-    kOptionsMask      = 2,
-    kOptionsOverride  = 3,
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnableLogging::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnableLogging
+namespace Language {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveToColorTemperature::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Language::Id; }
+};
 
-    uint16_t colorTemperature;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Language
+namespace LedSettings {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LedSettings::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace LedSettings
+namespace AutoRelockTime {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AutoRelockTime::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace AutoRelockTime
+namespace SoundVolume {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MoveToColorTemperature::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SoundVolume::Id; }
+};
 
-    uint16_t colorTemperature;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace SoundVolume
+namespace OperatingMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OperatingMode::Id; }
 };
-}; // namespace MoveToColorTemperature
-namespace EnhancedMoveToHue {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OperatingMode
+namespace SupportedOperatingModes {
+struct TypeInfo
 {
-    kEnhancedHue     = 0,
-    kDirection       = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SupportedOperatingModes::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace SupportedOperatingModes
+namespace DefaultConfigurationRegister {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return EnhancedMoveToHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DefaultConfigurationRegister::Id; }
+};
 
-    uint16_t enhancedHue;
-    HueDirection direction;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+using DecodableTypeInfo = TypeInfo;
+} // namespace DefaultConfigurationRegister
+namespace EnableLocalProgramming {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnableLocalProgramming::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnableLocalProgramming
+namespace EnableOneTouchLocking {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnableOneTouchLocking::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnableOneTouchLocking
+namespace EnableInsideStatusLed {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return EnhancedMoveToHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnableInsideStatusLed::Id; }
+};
 
-    uint16_t enhancedHue;
-    HueDirection direction;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnableInsideStatusLed
+namespace EnablePrivacyModeButton {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnablePrivacyModeButton::Id; }
 };
-}; // namespace EnhancedMoveToHue
-namespace EnhancedMoveHue {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnablePrivacyModeButton
+namespace WrongCodeEntryLimit {
+struct TypeInfo
 {
-    kMoveMode        = 0,
-    kRate            = 1,
-    kOptionsMask     = 2,
-    kOptionsOverride = 3,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WrongCodeEntryLimit::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace WrongCodeEntryLimit
+namespace UserCodeTemporaryDisableTime {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return EnhancedMoveHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UserCodeTemporaryDisableTime::Id; }
+};
 
-    HueMoveMode moveMode;
-    uint16_t rate;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+using DecodableTypeInfo = TypeInfo;
+} // namespace UserCodeTemporaryDisableTime
+namespace SendPinOverTheAir {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SendPinOverTheAir::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace SendPinOverTheAir
+namespace RequirePinForRfOperation {
+struct TypeInfo
+{
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RequirePinForRfOperation::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RequirePinForRfOperation
+namespace ZigbeeSecurityLevel {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return EnhancedMoveHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ZigbeeSecurityLevel::Id; }
+};
 
-    HueMoveMode moveMode;
-    uint16_t rate;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ZigbeeSecurityLevel
+namespace AlarmMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AlarmMask::Id; }
 };
-}; // namespace EnhancedMoveHue
-namespace EnhancedStepHue {
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AlarmMask
+namespace KeypadOperationEventMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::KeypadOperationEventMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace KeypadOperationEventMask
+namespace RfOperationEventMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RfOperationEventMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RfOperationEventMask
+namespace ManualOperationEventMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ManualOperationEventMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ManualOperationEventMask
+namespace RfidOperationEventMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RfidOperationEventMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RfidOperationEventMask
+namespace KeypadProgrammingEventMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::KeypadProgrammingEventMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace KeypadProgrammingEventMask
+namespace RfProgrammingEventMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RfProgrammingEventMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RfProgrammingEventMask
+namespace RfidProgrammingEventMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RfidProgrammingEventMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RfidProgrammingEventMask
+} // namespace Attributes
+} // namespace DoorLock
+namespace WindowCovering {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for WcEndProductType
+enum class WcEndProductType : uint8_t
+{
+    WC_END_PRODUCT_TYPE_ROLLER_SHADE                 = 0x00,
+    WC_END_PRODUCT_TYPE_ROMAN_SHADE                  = 0x01,
+    WC_END_PRODUCT_TYPE_BALLOON_SHADE                = 0x02,
+    WC_END_PRODUCT_TYPE_WOVEN_WOOD                   = 0x03,
+    WC_END_PRODUCT_TYPE_PLEATED_SHADE                = 0x04,
+    WC_END_PRODUCT_TYPE_CELLULAR_SHADE               = 0x05,
+    WC_END_PRODUCT_TYPE_LAYERED_SHADE                = 0x06,
+    WC_END_PRODUCT_TYPE_LAYERED_SHADE2_D             = 0x07,
+    WC_END_PRODUCT_TYPE_SHEER_SHADE                  = 0x08,
+    WC_END_PRODUCT_TYPE_TILT_ONLY_INTERIOR_BLIND     = 0x09,
+    WC_END_PRODUCT_TYPE_INTERIOR_BLIND               = 0x0A,
+    WC_END_PRODUCT_TYPE_VERTICAL_BLIND_STRIP_CURTAIN = 0x0B,
+    WC_END_PRODUCT_TYPE_INTERIOR_VENETIAN_BLIND      = 0x0C,
+    WC_END_PRODUCT_TYPE_EXTERIOR_VENETIAN_BLIND      = 0x0D,
+    WC_END_PRODUCT_TYPE_LATERAL_LEFT_CURTAIN         = 0x0E,
+    WC_END_PRODUCT_TYPE_LATERAL_RIGHT_CURTAIN        = 0x0F,
+    WC_END_PRODUCT_TYPE_CENTRAL_CURTAIN              = 0x10,
+    WC_END_PRODUCT_TYPE_ROLLER_SHUTTER               = 0x11,
+    WC_END_PRODUCT_TYPE_EXTERIOR_VERTICAL_SCREEN     = 0x12,
+    WC_END_PRODUCT_TYPE_AWNING_TERRACE_PATIO         = 0x13,
+    WC_END_PRODUCT_TYPE_AWNING_VERTICAL_SCREEN       = 0x14,
+    WC_END_PRODUCT_TYPE_TILT_ONLY_PERGOLA            = 0x15,
+    WC_END_PRODUCT_TYPE_SWINGING_SHUTTER             = 0x16,
+    WC_END_PRODUCT_TYPE_SLIDING_SHUTTER              = 0x17,
+    WC_END_PRODUCT_TYPE_UNKNOWN                      = 0xFF,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using WcEndProductType                     = EmberAfWcEndProductType;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for WcType
+enum class WcType : uint8_t
+{
+    WC_TYPE_ROLLERSHADE                 = 0x00,
+    WC_TYPE_ROLLERSHADE2_MOTOR          = 0x01,
+    WC_TYPE_ROLLERSHADE_EXTERIOR        = 0x02,
+    WC_TYPE_ROLLERSHADE_EXTERIOR2_MOTOR = 0x03,
+    WC_TYPE_DRAPERY                     = 0x04,
+    WC_TYPE_AWNING                      = 0x05,
+    WC_TYPE_SHUTTER                     = 0x06,
+    WC_TYPE_TILT_BLIND_TILT_ONLY        = 0x07,
+    WC_TYPE_TILT_BLIND_LIFT_AND_TILT    = 0x08,
+    WC_TYPE_PROJECTOR_SCREEN            = 0x09,
+    WC_TYPE_UNKNOWN                     = 0xFF,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using WcType                               = EmberAfWcType;
+#endif
+
+namespace Commands {
+namespace UpOrOpen {
 enum class Fields
 {
-    kStepMode        = 0,
-    kStepSize        = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return EnhancedStepHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
-
-    HueStepMode stepMode;
-    uint16_t stepSize;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    static constexpr CommandId GetCommandId() { return UpOrOpen::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8829,39 +11434,23 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return EnhancedStepHue::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return UpOrOpen::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    HueStepMode stepMode;
-    uint16_t stepSize;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace EnhancedStepHue
-namespace EnhancedMoveToHueAndSaturation {
+}; // namespace UpOrOpen
+namespace DownOrClose {
 enum class Fields
 {
-    kEnhancedHue     = 0,
-    kSaturation      = 1,
-    kTransitionTime  = 2,
-    kOptionsMask     = 3,
-    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return EnhancedMoveToHueAndSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
-
-    uint16_t enhancedHue;
-    uint8_t saturation;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    static constexpr CommandId GetCommandId() { return DownOrClose::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8869,43 +11458,23 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return EnhancedMoveToHueAndSaturation::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return DownOrClose::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    uint16_t enhancedHue;
-    uint8_t saturation;
-    uint16_t transitionTime;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace EnhancedMoveToHueAndSaturation
-namespace ColorLoopSet {
+}; // namespace DownOrClose
+namespace StopMotion {
 enum class Fields
 {
-    kUpdateFlags     = 0,
-    kAction          = 1,
-    kDirection       = 2,
-    kTime            = 3,
-    kStartHue        = 4,
-    kOptionsMask     = 5,
-    kOptionsOverride = 6,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ColorLoopSet::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
-
-    uint8_t updateFlags;
-    ColorLoopAction action;
-    ColorLoopDirection direction;
-    uint16_t time;
-    uint16_t startHue;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    static constexpr CommandId GetCommandId() { return StopMotion::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8913,35 +11482,26 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ColorLoopSet::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return StopMotion::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    uint8_t updateFlags;
-    ColorLoopAction action;
-    ColorLoopDirection direction;
-    uint16_t time;
-    uint16_t startHue;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ColorLoopSet
-namespace StopMoveStep {
+}; // namespace StopMotion
+namespace GoToLiftValue {
 enum class Fields
 {
-    kOptionsMask     = 0,
-    kOptionsOverride = 1,
+    kLiftValue = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StopMoveStep::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return GoToLiftValue::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint16_t liftValue;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8949,38 +11509,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return StopMoveStep::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return GoToLiftValue::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint16_t liftValue;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace StopMoveStep
-namespace MoveColorTemperature {
+}; // namespace GoToLiftValue
+namespace GoToLiftPercentage {
 enum class Fields
 {
-    kMoveMode                = 0,
-    kRate                    = 1,
-    kColorTemperatureMinimum = 2,
-    kColorTemperatureMaximum = 3,
-    kOptionsMask             = 4,
-    kOptionsOverride         = 5,
+    kLiftPercentageValue    = 0,
+    kLiftPercent100thsValue = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MoveColorTemperature::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return GoToLiftPercentage::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    HueMoveMode moveMode;
-    uint16_t rate;
-    uint16_t colorTemperatureMinimum;
-    uint16_t colorTemperatureMaximum;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t liftPercentageValue;
+    uint16_t liftPercent100thsValue;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -8988,44 +11539,28 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MoveColorTemperature::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return GoToLiftPercentage::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    HueMoveMode moveMode;
-    uint16_t rate;
-    uint16_t colorTemperatureMinimum;
-    uint16_t colorTemperatureMaximum;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint8_t liftPercentageValue;
+    uint16_t liftPercent100thsValue;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MoveColorTemperature
-namespace StepColorTemperature {
+}; // namespace GoToLiftPercentage
+namespace GoToTiltValue {
 enum class Fields
 {
-    kStepMode                = 0,
-    kStepSize                = 1,
-    kTransitionTime          = 2,
-    kColorTemperatureMinimum = 3,
-    kColorTemperatureMaximum = 4,
-    kOptionsMask             = 5,
-    kOptionsOverride         = 6,
+    kTiltValue = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StepColorTemperature::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return GoToTiltValue::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    HueStepMode stepMode;
-    uint16_t stepSize;
-    uint16_t transitionTime;
-    uint16_t colorTemperatureMinimum;
-    uint16_t colorTemperatureMaximum;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint16_t tiltValue;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9033,194 +11568,336 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return StepColorTemperature::Id; }
-    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr CommandId GetCommandId() { return GoToTiltValue::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-    HueStepMode stepMode;
-    uint16_t stepSize;
-    uint16_t transitionTime;
-    uint16_t colorTemperatureMinimum;
-    uint16_t colorTemperatureMaximum;
-    uint8_t optionsMask;
-    uint8_t optionsOverride;
+    uint16_t tiltValue;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace StepColorTemperature
-} // namespace Commands
-} // namespace ColorControl
-namespace BallastConfiguration {
+}; // namespace GoToTiltValue
+namespace GoToTiltPercentage {
+enum class Fields
+{
+    kTiltPercentageValue    = 0,
+    kTiltPercent100thsValue = 1,
+};
 
-} // namespace BallastConfiguration
-namespace IlluminanceMeasurement {
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GoToTiltPercentage::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-} // namespace IlluminanceMeasurement
-namespace IlluminanceLevelSensing {
+    uint8_t tiltPercentageValue;
+    uint16_t tiltPercent100thsValue;
 
-} // namespace IlluminanceLevelSensing
-namespace TemperatureMeasurement {
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
 
-} // namespace TemperatureMeasurement
-namespace PressureMeasurement {
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GoToTiltPercentage::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
-} // namespace PressureMeasurement
-namespace FlowMeasurement {
+    uint8_t tiltPercentageValue;
+    uint16_t tiltPercent100thsValue;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToTiltPercentage
+} // namespace Commands
 
-} // namespace FlowMeasurement
-namespace RelativeHumidityMeasurement {
+namespace Attributes {
+namespace Type {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Type::Id; }
+};
 
-} // namespace RelativeHumidityMeasurement
-namespace OccupancySensing {
+using DecodableTypeInfo = TypeInfo;
+} // namespace Type
+namespace PhysicalClosedLimitLift {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalClosedLimitLift::Id; }
+};
 
-} // namespace OccupancySensing
-namespace CarbonMonoxideConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhysicalClosedLimitLift
+namespace PhysicalClosedLimitTilt {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalClosedLimitTilt::Id; }
+};
 
-} // namespace CarbonMonoxideConcentrationMeasurement
-namespace CarbonDioxideConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhysicalClosedLimitTilt
+namespace CurrentPositionLift {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionLift::Id; }
+};
 
-} // namespace CarbonDioxideConcentrationMeasurement
-namespace EthyleneConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentPositionLift
+namespace CurrentPositionTilt {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionTilt::Id; }
+};
 
-} // namespace EthyleneConcentrationMeasurement
-namespace EthyleneOxideConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentPositionTilt
+namespace NumberOfActuationsLift {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfActuationsLift::Id; }
+};
 
-} // namespace EthyleneOxideConcentrationMeasurement
-namespace HydrogenConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumberOfActuationsLift
+namespace NumberOfActuationsTilt {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfActuationsTilt::Id; }
+};
 
-} // namespace HydrogenConcentrationMeasurement
-namespace HydrogenSulphideConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumberOfActuationsTilt
+namespace ConfigStatus {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ConfigStatus::Id; }
+};
 
-} // namespace HydrogenSulphideConcentrationMeasurement
-namespace NitricOxideConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace ConfigStatus
+namespace CurrentPositionLiftPercentage {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionLiftPercentage::Id; }
+};
 
-} // namespace NitricOxideConcentrationMeasurement
-namespace NitrogenDioxideConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentPositionLiftPercentage
+namespace CurrentPositionTiltPercentage {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionTiltPercentage::Id; }
+};
 
-} // namespace NitrogenDioxideConcentrationMeasurement
-namespace OxygenConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentPositionTiltPercentage
+namespace OperationalStatus {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OperationalStatus::Id; }
+};
 
-} // namespace OxygenConcentrationMeasurement
-namespace OzoneConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace OperationalStatus
+namespace TargetPositionLiftPercent100ths {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TargetPositionLiftPercent100ths::Id; }
+};
 
-} // namespace OzoneConcentrationMeasurement
-namespace SulfurDioxideConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace TargetPositionLiftPercent100ths
+namespace TargetPositionTiltPercent100ths {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TargetPositionTiltPercent100ths::Id; }
+};
 
-} // namespace SulfurDioxideConcentrationMeasurement
-namespace DissolvedOxygenConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace TargetPositionTiltPercent100ths
+namespace EndProductType {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EndProductType::Id; }
+};
 
-} // namespace DissolvedOxygenConcentrationMeasurement
-namespace BromateConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace EndProductType
+namespace CurrentPositionLiftPercent100ths {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionLiftPercent100ths::Id; }
+};
 
-} // namespace BromateConcentrationMeasurement
-namespace ChloraminesConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentPositionLiftPercent100ths
+namespace CurrentPositionTiltPercent100ths {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionTiltPercent100ths::Id; }
+};
 
-} // namespace ChloraminesConcentrationMeasurement
-namespace ChlorineConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentPositionTiltPercent100ths
+namespace InstalledOpenLimitLift {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstalledOpenLimitLift::Id; }
+};
 
-} // namespace ChlorineConcentrationMeasurement
-namespace FecalColiformAndEColiConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstalledOpenLimitLift
+namespace InstalledClosedLimitLift {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstalledClosedLimitLift::Id; }
+};
 
-} // namespace FecalColiformAndEColiConcentrationMeasurement
-namespace FluorideConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstalledClosedLimitLift
+namespace InstalledOpenLimitTilt {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstalledOpenLimitTilt::Id; }
+};
 
-} // namespace FluorideConcentrationMeasurement
-namespace HaloaceticAcidsConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstalledOpenLimitTilt
+namespace InstalledClosedLimitTilt {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstalledClosedLimitTilt::Id; }
+};
 
-} // namespace HaloaceticAcidsConcentrationMeasurement
-namespace TotalTrihalomethanesConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstalledClosedLimitTilt
+namespace VelocityLift {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::VelocityLift::Id; }
+};
 
-} // namespace TotalTrihalomethanesConcentrationMeasurement
-namespace TotalColiformBacteriaConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace VelocityLift
+namespace AccelerationTimeLift {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AccelerationTimeLift::Id; }
+};
 
-} // namespace TotalColiformBacteriaConcentrationMeasurement
-namespace TurbidityConcentrationMeasurement {
-
-} // namespace TurbidityConcentrationMeasurement
-namespace CopperConcentrationMeasurement {
-
-} // namespace CopperConcentrationMeasurement
-namespace LeadConcentrationMeasurement {
-
-} // namespace LeadConcentrationMeasurement
-namespace ManganeseConcentrationMeasurement {
-
-} // namespace ManganeseConcentrationMeasurement
-namespace SulfateConcentrationMeasurement {
-
-} // namespace SulfateConcentrationMeasurement
-namespace BromodichloromethaneConcentrationMeasurement {
-
-} // namespace BromodichloromethaneConcentrationMeasurement
-namespace BromoformConcentrationMeasurement {
-
-} // namespace BromoformConcentrationMeasurement
-namespace ChlorodibromomethaneConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace AccelerationTimeLift
+namespace DecelerationTimeLift {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DecelerationTimeLift::Id; }
+};
 
-} // namespace ChlorodibromomethaneConcentrationMeasurement
-namespace ChloroformConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace DecelerationTimeLift
+namespace Mode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Mode::Id; }
+};
 
-} // namespace ChloroformConcentrationMeasurement
-namespace SodiumConcentrationMeasurement {
+using DecodableTypeInfo = TypeInfo;
+} // namespace Mode
+namespace IntermediateSetpointsLift {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::IntermediateSetpointsLift::Id; }
+};
 
-} // namespace SodiumConcentrationMeasurement
-namespace IasZone {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasEnrollResponseCode
-enum class IasEnrollResponseCode : uint8_t
+using DecodableTypeInfo = TypeInfo;
+} // namespace IntermediateSetpointsLift
+namespace IntermediateSetpointsTilt {
+struct TypeInfo
 {
-    IAS_ENROLL_RESPONSE_CODE_SUCCESS          = 0x00,
-    IAS_ENROLL_RESPONSE_CODE_NOT_SUPPORTED    = 0x01,
-    IAS_ENROLL_RESPONSE_CODE_NO_ENROLL_PERMIT = 0x02,
-    IAS_ENROLL_RESPONSE_CODE_TOO_MANY_ZONES   = 0x03,
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::IntermediateSetpointsTilt::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasEnrollResponseCode                = EmberAfIasEnrollResponseCode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasZoneType
-enum class IasZoneType : uint16_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace IntermediateSetpointsTilt
+namespace SafetyStatus {
+struct TypeInfo
 {
-    IAS_ZONE_TYPE_STANDARD_CIE              = 0x00,
-    IAS_ZONE_TYPE_MOTION_SENSOR             = 0x0D,
-    IAS_ZONE_TYPE_CONTACT_SWITCH            = 0x15,
-    IAS_ZONE_TYPE_FIRE_SENSOR               = 0x28,
-    IAS_ZONE_TYPE_WATER_SENSOR              = 0x2A,
-    IAS_ZONE_TYPE_GAS_SENSOR                = 0x2B,
-    IAS_ZONE_TYPE_PERSONAL_EMERGENCY_DEVICE = 0x2C,
-    IAS_ZONE_TYPE_VIBRATION_MOVEMENT_SENSOR = 0x2D,
-    IAS_ZONE_TYPE_REMOTE_CONTROL            = 0x10F,
-    IAS_ZONE_TYPE_KEY_FOB                   = 0x115,
-    IAS_ZONE_TYPE_KEYPAD                    = 0x21D,
-    IAS_ZONE_TYPE_STANDARD_WARNING_DEVICE   = 0x225,
-    IAS_ZONE_TYPE_GLASS_BREAK_SENSOR        = 0x226,
-    IAS_ZONE_TYPE_CARBON_MONOXIDE_SENSOR    = 0x227,
-    IAS_ZONE_TYPE_SECURITY_REPEATER         = 0x229,
-    IAS_ZONE_TYPE_INVALID_ZONE_TYPE         = 0xFFFF,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SafetyStatus::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasZoneType                          = EmberAfIasZoneType;
-#endif
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SafetyStatus
+} // namespace Attributes
+} // namespace WindowCovering
+namespace BarrierControl {
 
 namespace Commands {
-namespace ZoneEnrollResponse {
+namespace BarrierControlGoToPercent {
 enum class Fields
 {
-    kEnrollResponseCode = 0,
-    kZoneId             = 1,
+    kPercentOpen = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ZoneEnrollResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr CommandId GetCommandId() { return BarrierControlGoToPercent::Id; }
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
 
-    IasEnrollResponseCode enrollResponseCode;
-    uint8_t zoneId;
+    uint8_t percentOpen;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9228,34 +11905,24 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ZoneEnrollResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr CommandId GetCommandId() { return BarrierControlGoToPercent::Id; }
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
 
-    IasEnrollResponseCode enrollResponseCode;
-    uint8_t zoneId;
+    uint8_t percentOpen;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ZoneEnrollResponse
-namespace ZoneStatusChangeNotification {
+}; // namespace BarrierControlGoToPercent
+namespace BarrierControlStop {
 enum class Fields
 {
-    kZoneStatus     = 0,
-    kExtendedStatus = 1,
-    kZoneId         = 2,
-    kDelay          = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ZoneStatusChangeNotification::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
-
-    uint16_t zoneStatus;
-    uint8_t extendedStatus;
-    uint8_t zoneId;
-    uint16_t delay;
+    static constexpr CommandId GetCommandId() { return BarrierControlStop::Id; }
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9263,319 +11930,424 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ZoneStatusChangeNotification::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr CommandId GetCommandId() { return BarrierControlStop::Id; }
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
 
-    uint16_t zoneStatus;
-    uint8_t extendedStatus;
-    uint8_t zoneId;
-    uint16_t delay;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ZoneStatusChangeNotification
-namespace InitiateNormalOperationMode {
-enum class Fields
+}; // namespace BarrierControlStop
+} // namespace Commands
+
+namespace Attributes {
+namespace BarrierMovingState {
+struct TypeInfo
 {
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierMovingState::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierMovingState
+namespace BarrierSafetyStatus {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return InitiateNormalOperationMode::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierSafetyStatus::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierSafetyStatus
+namespace BarrierCapabilities {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierCapabilities::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierCapabilities
+namespace BarrierOpenEvents {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return InitiateNormalOperationMode::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierOpenEvents::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierOpenEvents
+namespace BarrierCloseEvents {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierCloseEvents::Id; }
 };
-}; // namespace InitiateNormalOperationMode
-namespace ZoneEnrollRequest {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierCloseEvents
+namespace BarrierCommandOpenEvents {
+struct TypeInfo
 {
-    kZoneType         = 0,
-    kManufacturerCode = 1,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierCommandOpenEvents::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierCommandOpenEvents
+namespace BarrierCommandCloseEvents {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ZoneEnrollRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierCommandCloseEvents::Id; }
+};
 
-    IasZoneType zoneType;
-    uint16_t manufacturerCode;
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierCommandCloseEvents
+namespace BarrierOpenPeriod {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierOpenPeriod::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierOpenPeriod
+namespace BarrierClosePeriod {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierClosePeriod::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierClosePeriod
+namespace BarrierPosition {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return ZoneEnrollRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BarrierPosition::Id; }
+};
 
-    IasZoneType zoneType;
-    uint16_t manufacturerCode;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace BarrierPosition
+} // namespace Attributes
+} // namespace BarrierControl
+namespace PumpConfigurationAndControl {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for PumpControlMode
+enum class PumpControlMode : uint8_t
+{
+    PUMP_CONTROL_MODE_CONSTANT_SPEED        = 0x00,
+    PUMP_CONTROL_MODE_CONSTANT_PRESSURE     = 0x01,
+    PUMP_CONTROL_MODE_PROPORTIONAL_PRESSURE = 0x02,
+    PUMP_CONTROL_MODE_CONSTANT_FLOW         = 0x03,
+    PUMP_CONTROL_MODE_CONSTANT_TEMPERATURE  = 0x05,
+    PUMP_CONTROL_MODE_AUTOMATIC             = 0x07,
 };
-}; // namespace ZoneEnrollRequest
-namespace InitiateTestMode {
-enum class Fields
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using PumpControlMode                      = EmberAfPumpControlMode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for PumpOperationMode
+enum class PumpOperationMode : uint8_t
 {
-    kTestModeDuration            = 0,
-    kCurrentZoneSensitivityLevel = 1,
+    PUMP_OPERATION_MODE_NORMAL  = 0x00,
+    PUMP_OPERATION_MODE_MINIMUM = 0x01,
+    PUMP_OPERATION_MODE_MAXIMUM = 0x02,
+    PUMP_OPERATION_MODE_LOCAL   = 0x03,
 };
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using PumpOperationMode                    = EmberAfPumpOperationMode;
+#endif
 
-struct Type
+namespace Attributes {
+namespace MaxPressure {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return InitiateTestMode::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
-
-    uint8_t testModeDuration;
-    uint8_t currentZoneSensitivityLevel;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxPressure::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxPressure
+namespace MaxSpeed {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return InitiateTestMode::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
-
-    uint8_t testModeDuration;
-    uint8_t currentZoneSensitivityLevel;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxSpeed::Id; }
 };
-}; // namespace InitiateTestMode
-namespace InitiateNormalOperationModeResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxSpeed
+namespace MaxFlow {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxFlow::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxFlow
+namespace MinConstPressure {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return InitiateNormalOperationModeResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinConstPressure::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinConstPressure
+namespace MaxConstPressure {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxConstPressure::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxConstPressure
+namespace MinCompPressure {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return InitiateNormalOperationModeResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinCompPressure::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinCompPressure
+namespace MaxCompPressure {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxCompPressure::Id; }
 };
-}; // namespace InitiateNormalOperationModeResponse
-namespace InitiateTestModeResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxCompPressure
+namespace MinConstSpeed {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinConstSpeed::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinConstSpeed
+namespace MaxConstSpeed {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return InitiateTestModeResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxConstSpeed::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxConstSpeed
+namespace MinConstFlow {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinConstFlow::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinConstFlow
+namespace MaxConstFlow {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return InitiateTestModeResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxConstFlow::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxConstFlow
+namespace MinConstTemp {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinConstTemp::Id; }
 };
-}; // namespace InitiateTestModeResponse
-} // namespace Commands
-} // namespace IasZone
-namespace IasAce {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasAceAlarmStatus
-enum class IasAceAlarmStatus : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinConstTemp
+namespace MaxConstTemp {
+struct TypeInfo
 {
-    IAS_ACE_ALARM_STATUS_NO_ALARM        = 0x00,
-    IAS_ACE_ALARM_STATUS_BURGLAR         = 0x01,
-    IAS_ACE_ALARM_STATUS_FIRE            = 0x02,
-    IAS_ACE_ALARM_STATUS_EMERGENCY       = 0x03,
-    IAS_ACE_ALARM_STATUS_POLICE_PANIC    = 0x04,
-    IAS_ACE_ALARM_STATUS_FIRE_PANIC      = 0x05,
-    IAS_ACE_ALARM_STATUS_EMERGENCY_PANIC = 0x06,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxConstTemp::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasAceAlarmStatus                    = EmberAfIasAceAlarmStatus;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasAceArmMode
-enum class IasAceArmMode : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxConstTemp
+namespace PumpStatus {
+struct TypeInfo
 {
-    IAS_ACE_ARM_MODE_DISARM                     = 0x00,
-    IAS_ACE_ARM_MODE_ARM_DAY_HOME_ZONES_ONLY    = 0x01,
-    IAS_ACE_ARM_MODE_ARM_NIGHT_SLEEP_ZONES_ONLY = 0x02,
-    IAS_ACE_ARM_MODE_ARM_ALL_ZONES              = 0x03,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PumpStatus::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasAceArmMode                        = EmberAfIasAceArmMode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasAceArmNotification
-enum class IasAceArmNotification : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PumpStatus
+namespace EffectiveOperationMode {
+struct TypeInfo
 {
-    IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_DISARMED           = 0x00,
-    IAS_ACE_ARM_NOTIFICATION_ONLY_DAY_HOME_ZONES_ARMED    = 0x01,
-    IAS_ACE_ARM_NOTIFICATION_ONLY_NIGHT_SLEEP_ZONES_ARMED = 0x02,
-    IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_ARMED              = 0x03,
-    IAS_ACE_ARM_NOTIFICATION_INVALID_ARM_DISARM_CODE      = 0x04,
-    IAS_ACE_ARM_NOTIFICATION_NOT_READY_TO_ARM             = 0x05,
-    IAS_ACE_ARM_NOTIFICATION_ALREADY_DISARMED             = 0x06,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EffectiveOperationMode::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasAceArmNotification                = EmberAfIasAceArmNotification;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasAceAudibleNotification
-enum class IasAceAudibleNotification : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EffectiveOperationMode
+namespace EffectiveControlMode {
+struct TypeInfo
 {
-    IAS_ACE_AUDIBLE_NOTIFICATION_MUTE          = 0x00,
-    IAS_ACE_AUDIBLE_NOTIFICATION_DEFAULT_SOUND = 0x01,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EffectiveControlMode::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasAceAudibleNotification            = EmberAfIasAceAudibleNotification;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasAceBypassResult
-enum class IasAceBypassResult : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EffectiveControlMode
+namespace Capacity {
+struct TypeInfo
 {
-    IAS_ACE_BYPASS_RESULT_ZONE_BYPASSED           = 0x00,
-    IAS_ACE_BYPASS_RESULT_ZONE_NOT_BYPASSED       = 0x01,
-    IAS_ACE_BYPASS_RESULT_NOT_ALLOWED             = 0x02,
-    IAS_ACE_BYPASS_RESULT_INVALID_ZONE_ID         = 0x03,
-    IAS_ACE_BYPASS_RESULT_UNKNOWN_ZONE_ID         = 0x04,
-    IAS_ACE_BYPASS_RESULT_INVALID_ARM_DISARM_CODE = 0x05,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Capacity::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasAceBypassResult                   = EmberAfIasAceBypassResult;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasAcePanelStatus
-enum class IasAcePanelStatus : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Capacity
+namespace Speed {
+struct TypeInfo
 {
-    IAS_ACE_PANEL_STATUS_PANEL_DISARMED   = 0x00,
-    IAS_ACE_PANEL_STATUS_ARMED_STAY       = 0x01,
-    IAS_ACE_PANEL_STATUS_ARMED_NIGHT      = 0x02,
-    IAS_ACE_PANEL_STATUS_ARMED_AWAY       = 0x03,
-    IAS_ACE_PANEL_STATUS_EXIT_DELAY       = 0x04,
-    IAS_ACE_PANEL_STATUS_ENTRY_DELAY      = 0x05,
-    IAS_ACE_PANEL_STATUS_NOT_READY_TO_ARM = 0x06,
-    IAS_ACE_PANEL_STATUS_IN_ALARM         = 0x07,
-    IAS_ACE_PANEL_STATUS_ARMING_STAY      = 0x08,
-    IAS_ACE_PANEL_STATUS_ARMING_NIGHT     = 0x09,
-    IAS_ACE_PANEL_STATUS_ARMING_AWAY      = 0x0A,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Speed::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasAcePanelStatus                    = EmberAfIasAcePanelStatus;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for IasZoneType
-enum class IasZoneType : uint16_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Speed
+namespace LifetimeRunningHours {
+struct TypeInfo
 {
-    IAS_ZONE_TYPE_STANDARD_CIE              = 0x00,
-    IAS_ZONE_TYPE_MOTION_SENSOR             = 0x0D,
-    IAS_ZONE_TYPE_CONTACT_SWITCH            = 0x15,
-    IAS_ZONE_TYPE_FIRE_SENSOR               = 0x28,
-    IAS_ZONE_TYPE_WATER_SENSOR              = 0x2A,
-    IAS_ZONE_TYPE_GAS_SENSOR                = 0x2B,
-    IAS_ZONE_TYPE_PERSONAL_EMERGENCY_DEVICE = 0x2C,
-    IAS_ZONE_TYPE_VIBRATION_MOVEMENT_SENSOR = 0x2D,
-    IAS_ZONE_TYPE_REMOTE_CONTROL            = 0x10F,
-    IAS_ZONE_TYPE_KEY_FOB                   = 0x115,
-    IAS_ZONE_TYPE_KEYPAD                    = 0x21D,
-    IAS_ZONE_TYPE_STANDARD_WARNING_DEVICE   = 0x225,
-    IAS_ZONE_TYPE_GLASS_BREAK_SENSOR        = 0x226,
-    IAS_ZONE_TYPE_CARBON_MONOXIDE_SENSOR    = 0x227,
-    IAS_ZONE_TYPE_SECURITY_REPEATER         = 0x229,
-    IAS_ZONE_TYPE_INVALID_ZONE_TYPE         = 0xFFFF,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LifetimeRunningHours::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using IasZoneType                          = EmberAfIasZoneType;
-#endif
 
-namespace Structs {
-namespace IasAceZoneStatusResult {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace LifetimeRunningHours
+namespace Power {
+struct TypeInfo
 {
-    kZoneId     = 0,
-    kZoneStatus = 1,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Power::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Power
+namespace LifetimeEnergyConsumed {
+struct TypeInfo
 {
-public:
-    uint8_t zoneId;
-    uint16_t zoneStatus;
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LifetimeEnergyConsumed::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace LifetimeEnergyConsumed
+namespace OperationMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OperationMode::Id; }
 };
 
-using DecodableType = Type;
+using DecodableTypeInfo = TypeInfo;
+} // namespace OperationMode
+namespace ControlMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ControlMode::Id; }
+};
 
-} // namespace IasAceZoneStatusResult
-} // namespace Structs
+using DecodableTypeInfo = TypeInfo;
+} // namespace ControlMode
+namespace AlarmMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PumpConfigurationAndControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AlarmMask::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AlarmMask
+} // namespace Attributes
+} // namespace PumpConfigurationAndControl
+namespace Thermostat {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for SetpointAdjustMode
+enum class SetpointAdjustMode : uint8_t
+{
+    SETPOINT_ADJUST_MODE_HEAT_SETPOINT           = 0x00,
+    SETPOINT_ADJUST_MODE_COOL_SETPOINT           = 0x01,
+    SETPOINT_ADJUST_MODE_HEAT_AND_COOL_SETPOINTS = 0x02,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using SetpointAdjustMode                   = EmberAfSetpointAdjustMode;
+#endif
 
 namespace Commands {
-namespace Arm {
+namespace SetpointRaiseLower {
 enum class Fields
 {
-    kArmMode       = 0,
-    kArmDisarmCode = 1,
-    kZoneId        = 2,
+    kMode   = 0,
+    kAmount = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Arm::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return SetpointRaiseLower::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    IasAceArmMode armMode;
-    Span<const char> armDisarmCode;
-    uint8_t zoneId;
+    SetpointAdjustMode mode;
+    int8_t amount;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9583,29 +12355,34 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return Arm::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return SetpointRaiseLower::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    IasAceArmMode armMode;
-    Span<const char> armDisarmCode;
-    uint8_t zoneId;
+    SetpointAdjustMode mode;
+    int8_t amount;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace Arm
-namespace ArmResponse {
+}; // namespace SetpointRaiseLower
+namespace CurrentWeeklySchedule {
 enum class Fields
 {
-    kArmNotification = 0,
+    kNumberOfTransitionsForSequence = 0,
+    kDayOfWeekForSequence           = 1,
+    kModeForSequence                = 2,
+    kPayload                        = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ArmResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return CurrentWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    IasAceArmNotification armNotification;
+    uint8_t numberOfTransitionsForSequence;
+    uint8_t dayOfWeekForSequence;
+    uint8_t modeForSequence;
+    DataModel::List<uint8_t> payload;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9613,31 +12390,36 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ArmResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return CurrentWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    IasAceArmNotification armNotification;
+    uint8_t numberOfTransitionsForSequence;
+    uint8_t dayOfWeekForSequence;
+    uint8_t modeForSequence;
+    DataModel::DecodableList<uint8_t> payload;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ArmResponse
-namespace Bypass {
+}; // namespace CurrentWeeklySchedule
+namespace SetWeeklySchedule {
 enum class Fields
 {
-    kNumberOfZones = 0,
-    kZoneIds       = 1,
-    kArmDisarmCode = 2,
+    kNumberOfTransitionsForSequence = 0,
+    kDayOfWeekForSequence           = 1,
+    kModeForSequence                = 2,
+    kPayload                        = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Bypass::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return SetWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    uint8_t numberOfZones;
-    DataModel::List<uint8_t> zoneIds;
-    Span<const char> armDisarmCode;
+    uint8_t numberOfTransitionsForSequence;
+    uint8_t dayOfWeekForSequence;
+    uint8_t modeForSequence;
+    DataModel::List<uint8_t> payload;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9645,59 +12427,40 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return Bypass::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return SetWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    uint8_t numberOfZones;
-    DataModel::DecodableList<uint8_t> zoneIds;
-    Span<const char> armDisarmCode;
+    uint8_t numberOfTransitionsForSequence;
+    uint8_t dayOfWeekForSequence;
+    uint8_t modeForSequence;
+    DataModel::DecodableList<uint8_t> payload;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace Bypass
-namespace GetZoneIdMapResponse {
+}; // namespace SetWeeklySchedule
+namespace RelayStatusLog {
 enum class Fields
 {
-    kSection0  = 0,
-    kSection1  = 1,
-    kSection2  = 2,
-    kSection3  = 3,
-    kSection4  = 4,
-    kSection5  = 5,
-    kSection6  = 6,
-    kSection7  = 7,
-    kSection8  = 8,
-    kSection9  = 9,
-    kSection10 = 10,
-    kSection11 = 11,
-    kSection12 = 12,
-    kSection13 = 13,
-    kSection14 = 14,
-    kSection15 = 15,
+    kTimeOfDay            = 0,
+    kRelayStatus          = 1,
+    kLocalTemperature     = 2,
+    kHumidityInPercentage = 3,
+    kSetpoint             = 4,
+    kUnreadEntries        = 5,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetZoneIdMapResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return RelayStatusLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    uint16_t section0;
-    uint16_t section1;
-    uint16_t section2;
-    uint16_t section3;
-    uint16_t section4;
-    uint16_t section5;
-    uint16_t section6;
-    uint16_t section7;
-    uint16_t section8;
-    uint16_t section9;
-    uint16_t section10;
-    uint16_t section11;
-    uint16_t section12;
-    uint16_t section13;
-    uint16_t section14;
-    uint16_t section15;
+    uint16_t timeOfDay;
+    uint16_t relayStatus;
+    int16_t localTemperature;
+    uint8_t humidityInPercentage;
+    int16_t setpoint;
+    uint16_t unreadEntries;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9705,39 +12468,34 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetZoneIdMapResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return RelayStatusLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    uint16_t section0;
-    uint16_t section1;
-    uint16_t section2;
-    uint16_t section3;
-    uint16_t section4;
-    uint16_t section5;
-    uint16_t section6;
-    uint16_t section7;
-    uint16_t section8;
-    uint16_t section9;
-    uint16_t section10;
-    uint16_t section11;
-    uint16_t section12;
-    uint16_t section13;
-    uint16_t section14;
-    uint16_t section15;
+    uint16_t timeOfDay;
+    uint16_t relayStatus;
+    int16_t localTemperature;
+    uint8_t humidityInPercentage;
+    int16_t setpoint;
+    uint16_t unreadEntries;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetZoneIdMapResponse
-namespace Emergency {
+}; // namespace RelayStatusLog
+namespace GetWeeklySchedule {
 enum class Fields
 {
+    kDaysToReturn = 0,
+    kModeToReturn = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Emergency::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return GetWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+
+    uint8_t daysToReturn;
+    uint8_t modeToReturn;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9745,32 +12503,25 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return Emergency::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return GetWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
+    uint8_t daysToReturn;
+    uint8_t modeToReturn;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace Emergency
-namespace GetZoneInformationResponse {
+}; // namespace GetWeeklySchedule
+namespace ClearWeeklySchedule {
 enum class Fields
 {
-    kZoneId      = 0,
-    kZoneType    = 1,
-    kIeeeAddress = 2,
-    kZoneLabel   = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetZoneInformationResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    uint8_t zoneId;
-    IasZoneType zoneType;
-    chip::NodeId ieeeAddress;
-    Span<const char> zoneLabel;
+    static constexpr CommandId GetCommandId() { return ClearWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9778,17 +12529,13 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return GetZoneInformationResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return ClearWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
-    uint8_t zoneId;
-    IasZoneType zoneType;
-    chip::NodeId ieeeAddress;
-    Span<const char> zoneLabel;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace GetZoneInformationResponse
-namespace Fire {
+}; // namespace ClearWeeklySchedule
+namespace GetRelayStatusLog {
 enum class Fields
 {
 };
@@ -9797,8 +12544,8 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Fire::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return GetRelayStatusLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -9806,548 +12553,719 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return Fire::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    static constexpr CommandId GetCommandId() { return GetRelayStatusLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace Fire
-namespace ZoneStatusChanged {
-enum class Fields
+}; // namespace GetRelayStatusLog
+} // namespace Commands
+
+namespace Attributes {
+namespace LocalTemperature {
+struct TypeInfo
 {
-    kZoneId              = 0,
-    kZoneStatus          = 1,
-    kAudibleNotification = 2,
-    kZoneLabel           = 3,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LocalTemperature::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace LocalTemperature
+namespace OutdoorTemperature {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ZoneStatusChanged::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    uint8_t zoneId;
-    uint16_t zoneStatus;
-    IasAceAudibleNotification audibleNotification;
-    Span<const char> zoneLabel;
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OutdoorTemperature::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace OutdoorTemperature
+namespace Occupancy {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Occupancy::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace Occupancy
+namespace AbsMinHeatSetpointLimit {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return ZoneStatusChanged::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AbsMinHeatSetpointLimit::Id; }
+};
 
-    uint8_t zoneId;
-    uint16_t zoneStatus;
-    IasAceAudibleNotification audibleNotification;
-    Span<const char> zoneLabel;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace AbsMinHeatSetpointLimit
+namespace AbsMaxHeatSetpointLimit {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AbsMaxHeatSetpointLimit::Id; }
 };
-}; // namespace ZoneStatusChanged
-namespace Panic {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AbsMaxHeatSetpointLimit
+namespace AbsMinCoolSetpointLimit {
+struct TypeInfo
 {
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AbsMinCoolSetpointLimit::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AbsMinCoolSetpointLimit
+namespace AbsMaxCoolSetpointLimit {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Panic::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AbsMaxCoolSetpointLimit::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AbsMaxCoolSetpointLimit
+namespace PiCoolingDemand {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PiCoolingDemand::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace PiCoolingDemand
+namespace PiHeatingDemand {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return Panic::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PiHeatingDemand::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace PiHeatingDemand
+namespace HvacSystemTypeConfiguration {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HvacSystemTypeConfiguration::Id; }
 };
-}; // namespace Panic
-namespace PanelStatusChanged {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace HvacSystemTypeConfiguration
+namespace LocalTemperatureCalibration {
+struct TypeInfo
 {
-    kPanelStatus         = 0,
-    kSecondsRemaining    = 1,
-    kAudibleNotification = 2,
-    kAlarmStatus         = 3,
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LocalTemperatureCalibration::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace LocalTemperatureCalibration
+namespace OccupiedCoolingSetpoint {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return PanelStatusChanged::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OccupiedCoolingSetpoint::Id; }
+};
 
-    IasAcePanelStatus panelStatus;
-    uint8_t secondsRemaining;
-    IasAceAudibleNotification audibleNotification;
-    IasAceAlarmStatus alarmStatus;
+using DecodableTypeInfo = TypeInfo;
+} // namespace OccupiedCoolingSetpoint
+namespace OccupiedHeatingSetpoint {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OccupiedHeatingSetpoint::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace OccupiedHeatingSetpoint
+namespace UnoccupiedCoolingSetpoint {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UnoccupiedCoolingSetpoint::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace UnoccupiedCoolingSetpoint
+namespace UnoccupiedHeatingSetpoint {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return PanelStatusChanged::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UnoccupiedHeatingSetpoint::Id; }
+};
 
-    IasAcePanelStatus panelStatus;
-    uint8_t secondsRemaining;
-    IasAceAudibleNotification audibleNotification;
-    IasAceAlarmStatus alarmStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace UnoccupiedHeatingSetpoint
+namespace MinHeatSetpointLimit {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinHeatSetpointLimit::Id; }
 };
-}; // namespace PanelStatusChanged
-namespace GetZoneIdMap {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinHeatSetpointLimit
+namespace MaxHeatSetpointLimit {
+struct TypeInfo
 {
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxHeatSetpointLimit::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxHeatSetpointLimit
+namespace MinCoolSetpointLimit {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetZoneIdMap::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinCoolSetpointLimit::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinCoolSetpointLimit
+namespace MaxCoolSetpointLimit {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxCoolSetpointLimit::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxCoolSetpointLimit
+namespace MinSetpointDeadBand {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetZoneIdMap::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinSetpointDeadBand::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
-};
-}; // namespace GetZoneIdMap
-namespace GetPanelStatusResponse {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinSetpointDeadBand
+namespace RemoteSensing {
+struct TypeInfo
 {
-    kPanelStatus         = 0,
-    kSecondsRemaining    = 1,
-    kAudibleNotification = 2,
-    kAlarmStatus         = 3,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RemoteSensing::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RemoteSensing
+namespace ControlSequenceOfOperation {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetPanelStatusResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    IasAcePanelStatus panelStatus;
-    uint8_t secondsRemaining;
-    IasAceAudibleNotification audibleNotification;
-    IasAceAlarmStatus alarmStatus;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ControlSequenceOfOperation::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ControlSequenceOfOperation
+namespace SystemMode {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetPanelStatusResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    IasAcePanelStatus panelStatus;
-    uint8_t secondsRemaining;
-    IasAceAudibleNotification audibleNotification;
-    IasAceAlarmStatus alarmStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SystemMode::Id; }
 };
-}; // namespace GetPanelStatusResponse
-namespace GetZoneInformation {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SystemMode
+namespace AlarmMask {
+struct TypeInfo
 {
-    kZoneId = 0,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AlarmMask::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AlarmMask
+namespace ThermostatRunningMode {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetZoneInformation::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    uint8_t zoneId;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ThermostatRunningMode::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ThermostatRunningMode
+namespace StartOfWeek {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetZoneInformation::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    uint8_t zoneId;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StartOfWeek::Id; }
 };
-}; // namespace GetZoneInformation
-namespace SetBypassedZoneList {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace StartOfWeek
+namespace NumberOfWeeklyTransitions {
+struct TypeInfo
 {
-    kNumberOfZones = 0,
-    kZoneIds       = 1,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfWeeklyTransitions::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumberOfWeeklyTransitions
+namespace NumberOfDailyTransitions {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SetBypassedZoneList::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    uint8_t numberOfZones;
-    DataModel::List<uint8_t> zoneIds;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfDailyTransitions::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumberOfDailyTransitions
+namespace TemperatureSetpointHold {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return SetBypassedZoneList::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    uint8_t numberOfZones;
-    DataModel::DecodableList<uint8_t> zoneIds;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureSetpointHold::Id; }
 };
-}; // namespace SetBypassedZoneList
-namespace GetPanelStatus {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TemperatureSetpointHold
+namespace TemperatureSetpointHoldDuration {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureSetpointHoldDuration::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace TemperatureSetpointHoldDuration
+namespace ThermostatProgrammingOperationMode {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetPanelStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ThermostatProgrammingOperationMode::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ThermostatProgrammingOperationMode
+namespace HvacRelayState {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetPanelStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HvacRelayState::Id; }
 };
-}; // namespace GetPanelStatus
-namespace BypassResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace HvacRelayState
+namespace SetpointChangeSource {
+struct TypeInfo
 {
-    kNumberOfZones = 0,
-    kBypassResult  = 1,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SetpointChangeSource::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace SetpointChangeSource
+namespace SetpointChangeAmount {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return BypassResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    uint8_t numberOfZones;
-    DataModel::List<IasAceBypassResult> bypassResult;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SetpointChangeAmount::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace SetpointChangeAmount
+namespace SetpointChangeSourceTimestamp {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return BypassResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SetpointChangeSourceTimestamp::Id; }
+};
 
-    uint8_t numberOfZones;
-    DataModel::DecodableList<IasAceBypassResult> bypassResult;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace SetpointChangeSourceTimestamp
+namespace AcType {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcType::Id; }
 };
-}; // namespace BypassResponse
-namespace GetBypassedZoneList {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcType
+namespace AcCapacity {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcCapacity::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcCapacity
+namespace AcRefrigerantType {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetBypassedZoneList::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcRefrigerantType::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcRefrigerantType
+namespace AcCompressor {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcCompressor::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcCompressor
+namespace AcErrorCode {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetBypassedZoneList::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcErrorCode::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcErrorCode
+namespace AcLouverPosition {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcLouverPosition::Id; }
 };
-}; // namespace GetBypassedZoneList
-namespace GetZoneStatusResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcLouverPosition
+namespace AcCoilTemperature {
+struct TypeInfo
 {
-    kZoneStatusComplete = 0,
-    kNumberOfZones      = 1,
-    kZoneStatusResult   = 2,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcCoilTemperature::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcCoilTemperature
+namespace AcCapacityFormat {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetZoneStatusResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcCapacityFormat::Id; }
+};
 
-    bool zoneStatusComplete;
-    uint8_t numberOfZones;
-    DataModel::List<Structs::IasAceZoneStatusResult::Type> zoneStatusResult;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcCapacityFormat
+} // namespace Attributes
+} // namespace Thermostat
+namespace FanControl {
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+namespace Attributes {
+namespace FanMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return FanControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::FanMode::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace FanMode
+namespace FanModeSequence {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetZoneStatusResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
-
-    bool zoneStatusComplete;
-    uint8_t numberOfZones;
-    DataModel::DecodableList<Structs::IasAceZoneStatusResult::DecodableType> zoneStatusResult;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return FanControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::FanModeSequence::Id; }
 };
-}; // namespace GetZoneStatusResponse
-namespace GetZoneStatus {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace FanModeSequence
+} // namespace Attributes
+} // namespace FanControl
+namespace DehumidificationControl {
+
+namespace Attributes {
+namespace RelativeHumidity {
+struct TypeInfo
 {
-    kStartingZoneId     = 0,
-    kMaxNumberOfZoneIds = 1,
-    kZoneStatusMaskFlag = 2,
-    kZoneStatusMask     = 3,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DehumidificationControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RelativeHumidity::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RelativeHumidity
+namespace DehumidificationCooling {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetZoneStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DehumidificationControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DehumidificationCooling::Id; }
+};
 
-    uint8_t startingZoneId;
-    uint8_t maxNumberOfZoneIds;
-    bool zoneStatusMaskFlag;
-    uint16_t zoneStatusMask;
+using DecodableTypeInfo = TypeInfo;
+} // namespace DehumidificationCooling
+namespace RhDehumidificationSetpoint {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DehumidificationControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RhDehumidificationSetpoint::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace RhDehumidificationSetpoint
+namespace RelativeHumidityMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DehumidificationControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RelativeHumidityMode::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RelativeHumidityMode
+namespace DehumidificationLockout {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetZoneStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DehumidificationControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DehumidificationLockout::Id; }
+};
 
-    uint8_t startingZoneId;
-    uint8_t maxNumberOfZoneIds;
-    bool zoneStatusMaskFlag;
-    uint16_t zoneStatusMask;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace DehumidificationLockout
+namespace DehumidificationHysteresis {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DehumidificationControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DehumidificationHysteresis::Id; }
 };
-}; // namespace GetZoneStatus
-} // namespace Commands
-} // namespace IasAce
-namespace IasWd {
 
-namespace Commands {
-namespace StartWarning {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace DehumidificationHysteresis
+namespace DehumidificationMaxCool {
+struct TypeInfo
 {
-    kWarningInfo     = 0,
-    kWarningDuration = 1,
-    kStrobeDutyCycle = 2,
-    kStrobeLevel     = 3,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DehumidificationControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DehumidificationMaxCool::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace DehumidificationMaxCool
+namespace RelativeHumidityDisplay {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StartWarning::Id; }
-    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return DehumidificationControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RelativeHumidityDisplay::Id; }
+};
 
-    uint8_t warningInfo;
-    uint16_t warningDuration;
-    uint8_t strobeDutyCycle;
-    uint8_t strobeLevel;
+using DecodableTypeInfo = TypeInfo;
+} // namespace RelativeHumidityDisplay
+} // namespace Attributes
+} // namespace DehumidificationControl
+namespace ThermostatUserInterfaceConfiguration {
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+namespace Attributes {
+namespace TemperatureDisplayMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThermostatUserInterfaceConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureDisplayMode::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace TemperatureDisplayMode
+namespace KeypadLockout {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return StartWarning::Id; }
-    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThermostatUserInterfaceConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::KeypadLockout::Id; }
+};
 
-    uint8_t warningInfo;
-    uint16_t warningDuration;
-    uint8_t strobeDutyCycle;
-    uint8_t strobeLevel;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
-};
-}; // namespace StartWarning
-namespace Squawk {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace KeypadLockout
+namespace ScheduleProgrammingVisibility {
+struct TypeInfo
 {
-    kSquawkInfo = 0,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ThermostatUserInterfaceConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ScheduleProgrammingVisibility::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ScheduleProgrammingVisibility
+} // namespace Attributes
+} // namespace ThermostatUserInterfaceConfiguration
+namespace ColorControl {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for ColorLoopAction
+enum class ColorLoopAction : uint8_t
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Squawk::Id; }
-    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
-
-    uint8_t squawkInfo;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    COLOR_LOOP_ACTION_DEACTIVATE                                  = 0x00,
+    COLOR_LOOP_ACTION_ACTIVATE_FROM_COLOR_LOOP_START_ENHANCED_HUE = 0x01,
+    COLOR_LOOP_ACTION_ACTIVATE_FROM_ENHANCED_CURRENT_HUE          = 0x02,
 };
-
-struct DecodableType
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using ColorLoopAction                      = EmberAfColorLoopAction;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for ColorLoopDirection
+enum class ColorLoopDirection : uint8_t
 {
-public:
-    static constexpr CommandId GetCommandId() { return Squawk::Id; }
-    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
-
-    uint8_t squawkInfo;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    COLOR_LOOP_DIRECTION_DECREMENT_HUE = 0x00,
+    COLOR_LOOP_DIRECTION_INCREMENT_HUE = 0x01,
 };
-}; // namespace Squawk
-} // namespace Commands
-} // namespace IasWd
-namespace WakeOnLan {
-
-} // namespace WakeOnLan
-namespace TvChannel {
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using ColorLoopDirection                   = EmberAfColorLoopDirection;
+#endif
 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for TvChannelErrorType
-enum class TvChannelErrorType : uint8_t
+// Enum for ColorMode
+enum class ColorMode : uint8_t
 {
-    TV_CHANNEL_ERROR_TYPE_MULTIPLE_MATCHES = 0x00,
-    TV_CHANNEL_ERROR_TYPE_NO_MATCHES       = 0x01,
+    COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION = 0x00,
+    COLOR_MODE_CURRENT_X_AND_CURRENT_Y            = 0x01,
+    COLOR_MODE_COLOR_TEMPERATURE                  = 0x02,
 };
 #else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using TvChannelErrorType                   = EmberAfTvChannelErrorType;
+using ColorMode                            = EmberAfColorMode;
 #endif
 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for TvChannelLineupInfoType
-enum class TvChannelLineupInfoType : uint8_t
+// Enum for HueDirection
+enum class HueDirection : uint8_t
 {
-    TV_CHANNEL_LINEUP_INFO_TYPE_MSO = 0x00,
+    HUE_DIRECTION_SHORTEST_DISTANCE = 0x00,
+    HUE_DIRECTION_LONGEST_DISTANCE  = 0x01,
+    HUE_DIRECTION_UP                = 0x02,
+    HUE_DIRECTION_DOWN              = 0x03,
 };
 #else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using TvChannelLineupInfoType              = EmberAfTvChannelLineupInfoType;
+using HueDirection                         = EmberAfHueDirection;
 #endif
-
-namespace Structs {
-namespace TvChannelInfo {
-enum class Fields
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for HueMoveMode
+enum class HueMoveMode : uint8_t
 {
-    kMajorNumber       = 0,
-    kMinorNumber       = 1,
-    kName              = 2,
-    kCallSign          = 3,
-    kAffiliateCallSign = 4,
+    HUE_MOVE_MODE_STOP = 0x00,
+    HUE_MOVE_MODE_UP   = 0x01,
+    HUE_MOVE_MODE_DOWN = 0x03,
 };
-
-struct Type
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using HueMoveMode                          = EmberAfHueMoveMode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for HueStepMode
+enum class HueStepMode : uint8_t
 {
-public:
-    uint16_t majorNumber;
-    uint16_t minorNumber;
-    chip::ByteSpan name;
-    chip::ByteSpan callSign;
-    chip::ByteSpan affiliateCallSign;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    HUE_STEP_MODE_UP   = 0x01,
+    HUE_STEP_MODE_DOWN = 0x03,
 };
-
-using DecodableType = Type;
-
-} // namespace TvChannelInfo
-namespace TvChannelLineupInfo {
-enum class Fields
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using HueStepMode                          = EmberAfHueStepMode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for SaturationMoveMode
+enum class SaturationMoveMode : uint8_t
 {
-    kOperatorName   = 0,
-    kLineupName     = 1,
-    kPostalCode     = 2,
-    kLineupInfoType = 3,
+    SATURATION_MOVE_MODE_STOP = 0x00,
+    SATURATION_MOVE_MODE_UP   = 0x01,
+    SATURATION_MOVE_MODE_DOWN = 0x03,
 };
-
-struct Type
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using SaturationMoveMode                   = EmberAfSaturationMoveMode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for SaturationStepMode
+enum class SaturationStepMode : uint8_t
 {
-public:
-    Span<const char> operatorName;
-    Span<const char> lineupName;
-    Span<const char> postalCode;
-    TvChannelLineupInfoType lineupInfoType;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    SATURATION_STEP_MODE_UP   = 0x01,
+    SATURATION_STEP_MODE_DOWN = 0x03,
 };
-
-using DecodableType = Type;
-
-} // namespace TvChannelLineupInfo
-} // namespace Structs
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using SaturationStepMode                   = EmberAfSaturationStepMode;
+#endif
 
 namespace Commands {
-namespace ChangeChannel {
+namespace MoveToHue {
 enum class Fields
 {
-    kMatch = 0,
+    kHue             = 0,
+    kDirection       = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ChangeChannel::Id; }
-    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr CommandId GetCommandId() { return MoveToHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    Span<const char> match;
+    uint8_t hue;
+    HueDirection direction;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10355,29 +13273,37 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ChangeChannel::Id; }
-    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr CommandId GetCommandId() { return MoveToHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    Span<const char> match;
+    uint8_t hue;
+    HueDirection direction;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ChangeChannel
-namespace ChangeChannelResponse {
+}; // namespace MoveToHue
+namespace MoveHue {
 enum class Fields
 {
-    kChannelMatch = 0,
-    kErrorType    = 1,
+    kMoveMode        = 0,
+    kRate            = 1,
+    kOptionsMask     = 2,
+    kOptionsOverride = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ChangeChannelResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr CommandId GetCommandId() { return MoveHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    DataModel::List<Structs::TvChannelInfo::Type> channelMatch;
-    TvChannelErrorType errorType;
+    HueMoveMode moveMode;
+    uint8_t rate;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10385,30 +13311,38 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ChangeChannelResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr CommandId GetCommandId() { return MoveHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    DataModel::DecodableList<Structs::TvChannelInfo::DecodableType> channelMatch;
-    TvChannelErrorType errorType;
+    HueMoveMode moveMode;
+    uint8_t rate;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ChangeChannelResponse
-namespace ChangeChannelByNumber {
+}; // namespace MoveHue
+namespace StepHue {
 enum class Fields
 {
-    kMajorNumber = 0,
-    kMinorNumber = 1,
+    kStepMode        = 0,
+    kStepSize        = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ChangeChannelByNumber::Id; }
-    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr CommandId GetCommandId() { return StepHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    uint16_t majorNumber;
-    uint16_t minorNumber;
+    HueStepMode stepMode;
+    uint8_t stepSize;
+    uint8_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10416,28 +13350,37 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ChangeChannelByNumber::Id; }
-    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr CommandId GetCommandId() { return StepHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    uint16_t majorNumber;
-    uint16_t minorNumber;
+    HueStepMode stepMode;
+    uint8_t stepSize;
+    uint8_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ChangeChannelByNumber
-namespace SkipChannel {
+}; // namespace StepHue
+namespace MoveToSaturation {
 enum class Fields
 {
-    kCount = 0,
+    kSaturation      = 0,
+    kTransitionTime  = 1,
+    kOptionsMask     = 2,
+    kOptionsOverride = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SkipChannel::Id; }
-    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr CommandId GetCommandId() { return MoveToSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    uint16_t count;
+    uint8_t saturation;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10445,70 +13388,75 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SkipChannel::Id; }
-    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr CommandId GetCommandId() { return MoveToSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    uint16_t count;
+    uint8_t saturation;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SkipChannel
-} // namespace Commands
-} // namespace TvChannel
-namespace TargetNavigator {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for NavigateTargetStatus
-enum class NavigateTargetStatus : uint8_t
-{
-    NAVIGATE_TARGET_STATUS_SUCCESS           = 0x00,
-    NAVIGATE_TARGET_STATUS_APP_NOT_AVAILABLE = 0x01,
-    NAVIGATE_TARGET_STATUS_SYSTEM_BUSY       = 0x02,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using NavigateTargetStatus                 = EmberAfNavigateTargetStatus;
-#endif
-
-namespace Structs {
-namespace NavigateTargetTargetInfo {
+}; // namespace MoveToSaturation
+namespace MoveSaturation {
 enum class Fields
 {
-    kIdentifier = 0,
-    kName       = 1,
+    kMoveMode        = 0,
+    kRate            = 1,
+    kOptionsMask     = 2,
+    kOptionsOverride = 3,
 };
 
 struct Type
 {
 public:
-    uint8_t identifier;
-    chip::ByteSpan name;
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MoveSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    SaturationMoveMode moveMode;
+    uint8_t rate;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
 
-using DecodableType = Type;
-
-} // namespace NavigateTargetTargetInfo
-} // namespace Structs
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MoveSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-namespace Commands {
-namespace NavigateTarget {
+    SaturationMoveMode moveMode;
+    uint8_t rate;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveSaturation
+namespace StepSaturation {
 enum class Fields
 {
-    kTarget = 0,
-    kData   = 1,
+    kStepMode        = 0,
+    kStepSize        = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return NavigateTarget::Id; }
-    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+    static constexpr CommandId GetCommandId() { return StepSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    uint8_t target;
-    Span<const char> data;
+    SaturationStepMode stepMode;
+    uint8_t stepSize;
+    uint8_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10516,30 +13464,39 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return NavigateTarget::Id; }
-    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+    static constexpr CommandId GetCommandId() { return StepSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    uint8_t target;
-    Span<const char> data;
+    SaturationStepMode stepMode;
+    uint8_t stepSize;
+    uint8_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace NavigateTarget
-namespace NavigateTargetResponse {
+}; // namespace StepSaturation
+namespace MoveToHueAndSaturation {
 enum class Fields
 {
-    kStatus = 0,
-    kData   = 1,
+    kHue             = 0,
+    kSaturation      = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return NavigateTargetResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+    static constexpr CommandId GetCommandId() { return MoveToHueAndSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    NavigateTargetStatus status;
-    Span<const char> data;
+    uint8_t hue;
+    uint8_t saturation;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10547,83 +13504,77 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return NavigateTargetResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+    static constexpr CommandId GetCommandId() { return MoveToHueAndSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    NavigateTargetStatus status;
-    Span<const char> data;
+    uint8_t hue;
+    uint8_t saturation;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace NavigateTargetResponse
-} // namespace Commands
-} // namespace TargetNavigator
-namespace MediaPlayback {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for MediaPlaybackState
-enum class MediaPlaybackState : uint8_t
-{
-    MEDIA_PLAYBACK_STATE_PLAYING     = 0x00,
-    MEDIA_PLAYBACK_STATE_PAUSED      = 0x01,
-    MEDIA_PLAYBACK_STATE_NOT_PLAYING = 0x02,
-    MEDIA_PLAYBACK_STATE_BUFFERING   = 0x03,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using MediaPlaybackState                   = EmberAfMediaPlaybackState;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for MediaPlaybackStatus
-enum class MediaPlaybackStatus : uint8_t
-{
-    MEDIA_PLAYBACK_STATUS_SUCCESS                   = 0x00,
-    MEDIA_PLAYBACK_STATUS_INVALID_STATE_FOR_COMMAND = 0x01,
-    MEDIA_PLAYBACK_STATUS_NOT_ALLOWED               = 0x02,
-    MEDIA_PLAYBACK_STATUS_NOT_ACTIVE                = 0x03,
-    MEDIA_PLAYBACK_STATUS_SPEED_OUT_OF_RANGE        = 0x04,
-    MEDIA_PLAYBACK_STATUS_SEEK_OUT_OF_RANGE         = 0x05,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using MediaPlaybackStatus                  = EmberAfMediaPlaybackStatus;
-#endif
-
-namespace Structs {
-namespace MediaPlaybackPosition {
+}; // namespace MoveToHueAndSaturation
+namespace MoveToColor {
 enum class Fields
 {
-    kUpdatedAt = 0,
-    kPosition  = 1,
+    kColorX          = 0,
+    kColorY          = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
-    uint64_t updatedAt;
-    uint64_t position;
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MoveToColor::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    uint16_t colorX;
+    uint16_t colorY;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
 
-using DecodableType = Type;
-
-} // namespace MediaPlaybackPosition
-} // namespace Structs
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MoveToColor::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-namespace Commands {
-namespace MediaPlay {
+    uint16_t colorX;
+    uint16_t colorY;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToColor
+namespace MoveColor {
 enum class Fields
 {
+    kRateX           = 0,
+    kRateY           = 1,
+    kOptionsMask     = 2,
+    kOptionsOverride = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaPlay::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return MoveColor::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    int16_t rateX;
+    int16_t rateY;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10631,26 +13582,38 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaPlay::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return MoveColor::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    int16_t rateX;
+    int16_t rateY;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaPlay
-namespace MediaPlayResponse {
+}; // namespace MoveColor
+namespace StepColor {
 enum class Fields
 {
-    kMediaPlaybackStatus = 0,
+    kStepX           = 0,
+    kStepY           = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaPlayResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return StepColor::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    int16_t stepX;
+    int16_t stepY;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10658,24 +13621,37 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaPlayResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return StepColor::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    int16_t stepX;
+    int16_t stepY;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaPlayResponse
-namespace MediaPause {
+}; // namespace StepColor
+namespace MoveToColorTemperature {
 enum class Fields
 {
+    kColorTemperature = 0,
+    kTransitionTime   = 1,
+    kOptionsMask      = 2,
+    kOptionsOverride  = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaPause::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return MoveToColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    uint16_t colorTemperature;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10683,26 +13659,38 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaPause::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return MoveToColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    uint16_t colorTemperature;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaPause
-namespace MediaPauseResponse {
+}; // namespace MoveToColorTemperature
+namespace EnhancedMoveToHue {
 enum class Fields
 {
-    kMediaPlaybackStatus = 0,
+    kEnhancedHue     = 0,
+    kDirection       = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaPauseResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return EnhancedMoveToHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    uint16_t enhancedHue;
+    HueDirection direction;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10710,24 +13698,37 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaPauseResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return EnhancedMoveToHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    uint16_t enhancedHue;
+    HueDirection direction;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaPauseResponse
-namespace MediaStop {
+}; // namespace EnhancedMoveToHue
+namespace EnhancedMoveHue {
 enum class Fields
 {
+    kMoveMode        = 0,
+    kRate            = 1,
+    kOptionsMask     = 2,
+    kOptionsOverride = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaStop::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return EnhancedMoveHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    HueMoveMode moveMode;
+    uint16_t rate;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10735,26 +13736,38 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaStop::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return EnhancedMoveHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    HueMoveMode moveMode;
+    uint16_t rate;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaStop
-namespace MediaStopResponse {
+}; // namespace EnhancedMoveHue
+namespace EnhancedStepHue {
 enum class Fields
 {
-    kMediaPlaybackStatus = 0,
+    kStepMode        = 0,
+    kStepSize        = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaStopResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return EnhancedStepHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    HueStepMode stepMode;
+    uint16_t stepSize;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10762,24 +13775,39 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaStopResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return EnhancedStepHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    HueStepMode stepMode;
+    uint16_t stepSize;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaStopResponse
-namespace MediaStartOver {
+}; // namespace EnhancedStepHue
+namespace EnhancedMoveToHueAndSaturation {
 enum class Fields
 {
+    kEnhancedHue     = 0,
+    kSaturation      = 1,
+    kTransitionTime  = 2,
+    kOptionsMask     = 3,
+    kOptionsOverride = 4,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaStartOver::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return EnhancedMoveToHueAndSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    uint16_t enhancedHue;
+    uint8_t saturation;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10787,26 +13815,43 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaStartOver::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return EnhancedMoveToHueAndSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    uint16_t enhancedHue;
+    uint8_t saturation;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaStartOver
-namespace MediaStartOverResponse {
+}; // namespace EnhancedMoveToHueAndSaturation
+namespace ColorLoopSet {
 enum class Fields
 {
-    kMediaPlaybackStatus = 0,
+    kUpdateFlags     = 0,
+    kAction          = 1,
+    kDirection       = 2,
+    kTime            = 3,
+    kStartHue        = 4,
+    kOptionsMask     = 5,
+    kOptionsOverride = 6,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaStartOverResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return ColorLoopSet::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    uint8_t updateFlags;
+    ColorLoopAction action;
+    ColorLoopDirection direction;
+    uint16_t time;
+    uint16_t startHue;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10814,24 +13859,35 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaStartOverResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return ColorLoopSet::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    uint8_t updateFlags;
+    ColorLoopAction action;
+    ColorLoopDirection direction;
+    uint16_t time;
+    uint16_t startHue;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaStartOverResponse
-namespace MediaPrevious {
+}; // namespace ColorLoopSet
+namespace StopMoveStep {
 enum class Fields
 {
+    kOptionsMask     = 0,
+    kOptionsOverride = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaPrevious::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return StopMoveStep::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10839,26 +13895,38 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaPrevious::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return StopMoveStep::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaPrevious
-namespace MediaPreviousResponse {
+}; // namespace StopMoveStep
+namespace MoveColorTemperature {
 enum class Fields
 {
-    kMediaPlaybackStatus = 0,
+    kMoveMode                = 0,
+    kRate                    = 1,
+    kColorTemperatureMinimum = 2,
+    kColorTemperatureMaximum = 3,
+    kOptionsMask             = 4,
+    kOptionsOverride         = 5,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaPreviousResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return MoveColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    HueMoveMode moveMode;
+    uint16_t rate;
+    uint16_t colorTemperatureMinimum;
+    uint16_t colorTemperatureMaximum;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10866,51 +13934,44 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaPreviousResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return MoveColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    HueMoveMode moveMode;
+    uint16_t rate;
+    uint16_t colorTemperatureMinimum;
+    uint16_t colorTemperatureMaximum;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaPreviousResponse
-namespace MediaNext {
+}; // namespace MoveColorTemperature
+namespace StepColorTemperature {
 enum class Fields
 {
+    kStepMode                = 0,
+    kStepSize                = 1,
+    kTransitionTime          = 2,
+    kColorTemperatureMinimum = 3,
+    kColorTemperatureMaximum = 4,
+    kOptionsMask             = 5,
+    kOptionsOverride         = 6,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaNext::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-};
-
-struct DecodableType
-{
-public:
-    static constexpr CommandId GetCommandId() { return MediaNext::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
-
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
-};
-}; // namespace MediaNext
-namespace MediaNextResponse {
-enum class Fields
-{
-    kMediaPlaybackStatus = 0,
-};
-
-struct Type
-{
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaNextResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return StepColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    HueStepMode stepMode;
+    uint16_t stepSize;
+    uint16_t transitionTime;
+    uint16_t colorTemperatureMinimum;
+    uint16_t colorTemperatureMaximum;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -10918,603 +13979,6304 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return MediaNextResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr CommandId GetCommandId() { return StepColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+    HueStepMode stepMode;
+    uint16_t stepSize;
+    uint16_t transitionTime;
+    uint16_t colorTemperatureMinimum;
+    uint16_t colorTemperatureMaximum;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace MediaNextResponse
-namespace MediaRewind {
-enum class Fields
+}; // namespace StepColorTemperature
+} // namespace Commands
+
+namespace Attributes {
+namespace CurrentHue {
+struct TypeInfo
 {
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHue::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentHue
+namespace CurrentSaturation {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaRewind::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentSaturation::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentSaturation
+namespace RemainingTime {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaRewind::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RemainingTime::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RemainingTime
+namespace CurrentX {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentX::Id; }
 };
-}; // namespace MediaRewind
-namespace MediaRewindResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentX
+namespace CurrentY {
+struct TypeInfo
 {
-    kMediaPlaybackStatus = 0,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentY::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentY
+namespace DriftCompensation {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaRewindResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DriftCompensation::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+using DecodableTypeInfo = TypeInfo;
+} // namespace DriftCompensation
+namespace CompensationText {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CompensationText::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace CompensationText
+namespace ColorTemperature {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorTemperature::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorTemperature
+namespace ColorMode {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaRewindResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorMode::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorMode
+namespace ColorControlOptions {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorControlOptions::Id; }
 };
-}; // namespace MediaRewindResponse
-namespace MediaFastForward {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorControlOptions
+namespace NumberOfPrimaries {
+struct TypeInfo
 {
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfPrimaries::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumberOfPrimaries
+namespace Primary1X {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaFastForward::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary1X::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary1X
+namespace Primary1Y {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary1Y::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary1Y
+namespace Primary1Intensity {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaFastForward::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary1Intensity::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary1Intensity
+namespace Primary2X {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary2X::Id; }
 };
-}; // namespace MediaFastForward
-namespace MediaFastForwardResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary2X
+namespace Primary2Y {
+struct TypeInfo
 {
-    kMediaPlaybackStatus = 0,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary2Y::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary2Y
+namespace Primary2Intensity {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaFastForwardResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary2Intensity::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary2Intensity
+namespace Primary3X {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary3X::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary3X
+namespace Primary3Y {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary3Y::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary3Y
+namespace Primary3Intensity {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaFastForwardResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary3Intensity::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary3Intensity
+namespace Primary4X {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary4X::Id; }
 };
-}; // namespace MediaFastForwardResponse
-namespace MediaSkipForward {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary4X
+namespace Primary4Y {
+struct TypeInfo
 {
-    kDeltaPositionMilliseconds = 0,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary4Y::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary4Y
+namespace Primary4Intensity {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaSkipForward::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary4Intensity::Id; }
+};
 
-    uint64_t deltaPositionMilliseconds;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary4Intensity
+namespace Primary5X {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary5X::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary5X
+namespace Primary5Y {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary5Y::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary5Y
+namespace Primary5Intensity {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaSkipForward::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary5Intensity::Id; }
+};
 
-    uint64_t deltaPositionMilliseconds;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary5Intensity
+namespace Primary6X {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary6X::Id; }
 };
-}; // namespace MediaSkipForward
-namespace MediaSkipForwardResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary6X
+namespace Primary6Y {
+struct TypeInfo
 {
-    kMediaPlaybackStatus = 0,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary6Y::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary6Y
+namespace Primary6Intensity {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaSkipForwardResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Primary6Intensity::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Primary6Intensity
+namespace WhitePointX {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WhitePointX::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace WhitePointX
+namespace WhitePointY {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WhitePointY::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace WhitePointY
+namespace ColorPointRX {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaSkipForwardResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointRX::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointRX
+namespace ColorPointRY {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointRY::Id; }
 };
-}; // namespace MediaSkipForwardResponse
-namespace MediaSkipBackward {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointRY
+namespace ColorPointRIntensity {
+struct TypeInfo
 {
-    kDeltaPositionMilliseconds = 0,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointRIntensity::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointRIntensity
+namespace ColorPointGX {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaSkipBackward::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointGX::Id; }
+};
 
-    uint64_t deltaPositionMilliseconds;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointGX
+namespace ColorPointGY {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointGY::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointGY
+namespace ColorPointGIntensity {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointGIntensity::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointGIntensity
+namespace ColorPointBX {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaSkipBackward::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointBX::Id; }
+};
 
-    uint64_t deltaPositionMilliseconds;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointBX
+namespace ColorPointBY {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointBY::Id; }
 };
-}; // namespace MediaSkipBackward
-namespace MediaSkipBackwardResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointBY
+namespace ColorPointBIntensity {
+struct TypeInfo
 {
-    kMediaPlaybackStatus = 0,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointBIntensity::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorPointBIntensity
+namespace EnhancedCurrentHue {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaSkipBackwardResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnhancedCurrentHue::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnhancedCurrentHue
+namespace EnhancedColorMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EnhancedColorMode::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace EnhancedColorMode
+namespace ColorLoopActive {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopActive::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorLoopActive
+namespace ColorLoopDirection {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaSkipBackwardResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopDirection::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorLoopDirection
+namespace ColorLoopTime {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopTime::Id; }
 };
-}; // namespace MediaSkipBackwardResponse
-namespace MediaSeek {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorLoopTime
+namespace ColorLoopStartEnhancedHue {
+struct TypeInfo
 {
-    kPosition = 0,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopStartEnhancedHue::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorLoopStartEnhancedHue
+namespace ColorLoopStoredEnhancedHue {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaSeek::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopStoredEnhancedHue::Id; }
+};
 
-    uint64_t position;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorLoopStoredEnhancedHue
+namespace ColorCapabilities {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorCapabilities::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorCapabilities
+namespace ColorTempPhysicalMin {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorTempPhysicalMin::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorTempPhysicalMin
+namespace ColorTempPhysicalMax {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaSeek::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ColorTempPhysicalMax::Id; }
+};
 
-    uint64_t position;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ColorTempPhysicalMax
+namespace CoupleColorTempToLevelMinMireds {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CoupleColorTempToLevelMinMireds::Id; }
 };
-}; // namespace MediaSeek
-namespace MediaSeekResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CoupleColorTempToLevelMinMireds
+namespace StartUpColorTemperatureMireds {
+struct TypeInfo
 {
-    kMediaPlaybackStatus = 0,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StartUpColorTemperatureMireds::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace StartUpColorTemperatureMireds
+} // namespace Attributes
+} // namespace ColorControl
+namespace BallastConfiguration {
+
+namespace Attributes {
+namespace PhysicalMinLevel {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MediaSeekResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalMinLevel::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhysicalMinLevel
+namespace PhysicalMaxLevel {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalMaxLevel::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhysicalMaxLevel
+namespace BallastStatus {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BallastStatus::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace BallastStatus
+namespace MinLevel {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MediaSeekResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinLevel::Id; }
+};
 
-    MediaPlaybackStatus mediaPlaybackStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinLevel
+namespace MaxLevel {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxLevel::Id; }
 };
-}; // namespace MediaSeekResponse
-} // namespace Commands
-} // namespace MediaPlayback
-namespace MediaInput {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for MediaInputType
-enum class MediaInputType : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxLevel
+namespace PowerOnLevel {
+struct TypeInfo
 {
-    MEDIA_INPUT_TYPE_INTERNAL  = 0x00,
-    MEDIA_INPUT_TYPE_AUX       = 0x01,
-    MEDIA_INPUT_TYPE_COAX      = 0x02,
-    MEDIA_INPUT_TYPE_COMPOSITE = 0x03,
-    MEDIA_INPUT_TYPE_HDMI      = 0x04,
-    MEDIA_INPUT_TYPE_INPUT     = 0x05,
-    MEDIA_INPUT_TYPE_LINE      = 0x06,
-    MEDIA_INPUT_TYPE_OPTICAL   = 0x07,
-    MEDIA_INPUT_TYPE_VIDEO     = 0x08,
-    MEDIA_INPUT_TYPE_SCART     = 0x09,
-    MEDIA_INPUT_TYPE_USB       = 0x0A,
-    MEDIA_INPUT_TYPE_OTHER     = 0x0B,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PowerOnLevel::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using MediaInputType                       = EmberAfMediaInputType;
-#endif
 
-namespace Structs {
-namespace MediaInputInfo {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace PowerOnLevel
+namespace PowerOnFadeTime {
+struct TypeInfo
 {
-    kIndex       = 0,
-    kInputType   = 1,
-    kName        = 2,
-    kDescription = 3,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PowerOnFadeTime::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace PowerOnFadeTime
+namespace IntrinsicBallastFactor {
+struct TypeInfo
 {
-public:
-    uint8_t index;
-    MediaInputType inputType;
-    chip::ByteSpan name;
-    chip::ByteSpan description;
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::IntrinsicBallastFactor::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace IntrinsicBallastFactor
+namespace BallastFactorAdjustment {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BallastFactorAdjustment::Id; }
 };
 
-using DecodableType = Type;
+using DecodableTypeInfo = TypeInfo;
+} // namespace BallastFactorAdjustment
+namespace LampQuality {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LampQuality::Id; }
+};
 
-} // namespace MediaInputInfo
-} // namespace Structs
+using DecodableTypeInfo = TypeInfo;
+} // namespace LampQuality
+namespace LampType {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LampType::Id; }
+};
 
-namespace Commands {
-namespace SelectInput {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace LampType
+namespace LampManufacturer {
+struct TypeInfo
 {
-    kIndex = 0,
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LampManufacturer::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace LampManufacturer
+namespace LampRatedHours {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SelectInput::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LampRatedHours::Id; }
+};
 
-    uint8_t index;
+using DecodableTypeInfo = TypeInfo;
+} // namespace LampRatedHours
+namespace LampBurnHours {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LampBurnHours::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace LampBurnHours
+namespace LampAlarmMode {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LampAlarmMode::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace LampAlarmMode
+namespace LampBurnHoursTripPoint {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return SelectInput::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return BallastConfiguration::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LampBurnHoursTripPoint::Id; }
+};
 
-    uint8_t index;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace LampBurnHoursTripPoint
+} // namespace Attributes
+} // namespace BallastConfiguration
+namespace IlluminanceMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return IlluminanceMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
 };
-}; // namespace SelectInput
-namespace ShowInputStatus {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return IlluminanceMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ShowInputStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return IlluminanceMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return IlluminanceMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+namespace LightSensorType {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return ShowInputStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return IlluminanceMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LightSensorType::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace LightSensorType
+} // namespace Attributes
+} // namespace IlluminanceMeasurement
+namespace IlluminanceLevelSensing {
+
+namespace Attributes {
+namespace LevelStatus {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return IlluminanceLevelSensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LevelStatus::Id; }
 };
-}; // namespace ShowInputStatus
-namespace HideInputStatus {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LevelStatus
+namespace LightSensorType {
+struct TypeInfo
 {
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return IlluminanceLevelSensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LightSensorType::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace LightSensorType
+namespace IlluminanceLevelTarget {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return HideInputStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return IlluminanceLevelSensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::IlluminanceLevelTarget::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace IlluminanceLevelTarget
+} // namespace Attributes
+} // namespace IlluminanceLevelSensing
+namespace TemperatureMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return TemperatureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return HideInputStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return TemperatureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return TemperatureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
 };
-}; // namespace HideInputStatus
-namespace RenameInput {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
 {
-    kIndex = 0,
-    kName  = 1,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return TemperatureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace TemperatureMeasurement
+namespace PressureMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return RenameInput::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
 
-    uint8_t index;
-    Span<const char> name;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return RenameInput::Id; }
-    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
 
-    uint8_t index;
-    Span<const char> name;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+namespace ScaledValue {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ScaledValue::Id; }
 };
-}; // namespace RenameInput
-} // namespace Commands
-} // namespace MediaInput
-namespace LowPower {
 
-namespace Commands {
-namespace Sleep {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace ScaledValue
+namespace MinScaledValue {
+struct TypeInfo
 {
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinScaledValue::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinScaledValue
+namespace MaxScaledValue {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Sleep::Id; }
-    static constexpr ClusterId GetClusterId() { return LowPower::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxScaledValue::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxScaledValue
+namespace ScaledTolerance {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ScaledTolerance::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ScaledTolerance
+namespace Scale {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return Sleep::Id; }
-    static constexpr ClusterId GetClusterId() { return LowPower::Id; }
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return PressureMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Scale::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Scale
+} // namespace Attributes
+} // namespace PressureMeasurement
+namespace FlowMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return FlowMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
 };
-}; // namespace Sleep
-} // namespace Commands
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return FlowMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return FlowMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return FlowMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace FlowMeasurement
+namespace RelativeHumidityMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return RelativeHumidityMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return RelativeHumidityMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return RelativeHumidityMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return RelativeHumidityMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace RelativeHumidityMeasurement
+namespace OccupancySensing {
+
+namespace Attributes {
+namespace Occupancy {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Occupancy::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Occupancy
+namespace OccupancySensorType {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OccupancySensorType::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OccupancySensorType
+namespace OccupancySensorTypeBitmap {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OccupancySensorTypeBitmap::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace OccupancySensorTypeBitmap
+namespace PirOccupiedToUnoccupiedDelay {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PirOccupiedToUnoccupiedDelay::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PirOccupiedToUnoccupiedDelay
+namespace PirUnoccupiedToOccupiedDelay {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PirUnoccupiedToOccupiedDelay::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PirUnoccupiedToOccupiedDelay
+namespace PirUnoccupiedToOccupiedThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PirUnoccupiedToOccupiedThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PirUnoccupiedToOccupiedThreshold
+namespace UltrasonicOccupiedToUnoccupiedDelay {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UltrasonicOccupiedToUnoccupiedDelay::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace UltrasonicOccupiedToUnoccupiedDelay
+namespace UltrasonicUnoccupiedToOccupiedDelay {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UltrasonicUnoccupiedToOccupiedDelay::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace UltrasonicUnoccupiedToOccupiedDelay
+namespace UltrasonicUnoccupiedToOccupiedThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UltrasonicUnoccupiedToOccupiedThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace UltrasonicUnoccupiedToOccupiedThreshold
+namespace PhysicalContactOccupiedToUnoccupiedDelay {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalContactOccupiedToUnoccupiedDelay::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhysicalContactOccupiedToUnoccupiedDelay
+namespace PhysicalContactUnoccupiedToOccupiedDelay {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalContactUnoccupiedToOccupiedDelay::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhysicalContactUnoccupiedToOccupiedDelay
+namespace PhysicalContactUnoccupiedToOccupiedThreshold {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return OccupancySensing::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhysicalContactUnoccupiedToOccupiedThreshold
+} // namespace Attributes
+} // namespace OccupancySensing
+namespace CarbonMonoxideConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CarbonMonoxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CarbonMonoxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CarbonMonoxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CarbonMonoxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace CarbonMonoxideConcentrationMeasurement
+namespace CarbonDioxideConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CarbonDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CarbonDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CarbonDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CarbonDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace CarbonDioxideConcentrationMeasurement
+namespace EthyleneConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return EthyleneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return EthyleneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return EthyleneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return EthyleneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace EthyleneConcentrationMeasurement
+namespace EthyleneOxideConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return EthyleneOxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return EthyleneOxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return EthyleneOxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return EthyleneOxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace EthyleneOxideConcentrationMeasurement
+namespace HydrogenConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HydrogenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HydrogenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HydrogenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HydrogenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace HydrogenConcentrationMeasurement
+namespace HydrogenSulphideConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HydrogenSulphideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HydrogenSulphideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HydrogenSulphideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HydrogenSulphideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace HydrogenSulphideConcentrationMeasurement
+namespace NitricOxideConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return NitricOxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return NitricOxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return NitricOxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return NitricOxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace NitricOxideConcentrationMeasurement
+namespace NitrogenDioxideConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return NitrogenDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return NitrogenDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return NitrogenDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return NitrogenDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace NitrogenDioxideConcentrationMeasurement
+namespace OxygenConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return OxygenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return OxygenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return OxygenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return OxygenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace OxygenConcentrationMeasurement
+namespace OzoneConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return OzoneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return OzoneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return OzoneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return OzoneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace OzoneConcentrationMeasurement
+namespace SulfurDioxideConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SulfurDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SulfurDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SulfurDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SulfurDioxideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace SulfurDioxideConcentrationMeasurement
+namespace DissolvedOxygenConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return DissolvedOxygenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return DissolvedOxygenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return DissolvedOxygenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return DissolvedOxygenConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace DissolvedOxygenConcentrationMeasurement
+namespace BromateConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromateConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromateConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromateConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromateConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace BromateConcentrationMeasurement
+namespace ChloraminesConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChloraminesConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChloraminesConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChloraminesConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChloraminesConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace ChloraminesConcentrationMeasurement
+namespace ChlorineConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChlorineConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChlorineConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChlorineConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChlorineConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace ChlorineConcentrationMeasurement
+namespace FecalColiformAndEColiConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return FecalColiformAndEColiConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return FecalColiformAndEColiConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return FecalColiformAndEColiConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return FecalColiformAndEColiConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace FecalColiformAndEColiConcentrationMeasurement
+namespace FluorideConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return FluorideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return FluorideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return FluorideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return FluorideConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace FluorideConcentrationMeasurement
+namespace HaloaceticAcidsConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HaloaceticAcidsConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HaloaceticAcidsConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HaloaceticAcidsConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return HaloaceticAcidsConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace HaloaceticAcidsConcentrationMeasurement
+namespace TotalTrihalomethanesConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TotalTrihalomethanesConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TotalTrihalomethanesConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TotalTrihalomethanesConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TotalTrihalomethanesConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace TotalTrihalomethanesConcentrationMeasurement
+namespace TotalColiformBacteriaConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TotalColiformBacteriaConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TotalColiformBacteriaConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TotalColiformBacteriaConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TotalColiformBacteriaConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace TotalColiformBacteriaConcentrationMeasurement
+namespace TurbidityConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TurbidityConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TurbidityConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TurbidityConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return TurbidityConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace TurbidityConcentrationMeasurement
+namespace CopperConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CopperConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CopperConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CopperConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return CopperConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace CopperConcentrationMeasurement
+namespace LeadConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return LeadConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return LeadConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return LeadConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return LeadConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace LeadConcentrationMeasurement
+namespace ManganeseConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ManganeseConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ManganeseConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ManganeseConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ManganeseConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace ManganeseConcentrationMeasurement
+namespace SulfateConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SulfateConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SulfateConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SulfateConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SulfateConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace SulfateConcentrationMeasurement
+namespace BromodichloromethaneConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromodichloromethaneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromodichloromethaneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromodichloromethaneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromodichloromethaneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace BromodichloromethaneConcentrationMeasurement
+namespace BromoformConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromoformConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromoformConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromoformConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return BromoformConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace BromoformConcentrationMeasurement
+namespace ChlorodibromomethaneConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChlorodibromomethaneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChlorodibromomethaneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChlorodibromomethaneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChlorodibromomethaneConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace ChlorodibromomethaneConcentrationMeasurement
+namespace ChloroformConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChloroformConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChloroformConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChloroformConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return ChloroformConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace ChloroformConcentrationMeasurement
+namespace SodiumConcentrationMeasurement {
+
+namespace Attributes {
+namespace MeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SodiumConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SodiumConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SodiumConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+    using Type = float;
+    static constexpr ClusterId GetClusterId() { return SodiumConcentrationMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Tolerance
+} // namespace Attributes
+} // namespace SodiumConcentrationMeasurement
+namespace IasZone {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasEnrollResponseCode
+enum class IasEnrollResponseCode : uint8_t
+{
+    IAS_ENROLL_RESPONSE_CODE_SUCCESS          = 0x00,
+    IAS_ENROLL_RESPONSE_CODE_NOT_SUPPORTED    = 0x01,
+    IAS_ENROLL_RESPONSE_CODE_NO_ENROLL_PERMIT = 0x02,
+    IAS_ENROLL_RESPONSE_CODE_TOO_MANY_ZONES   = 0x03,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasEnrollResponseCode                = EmberAfIasEnrollResponseCode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasZoneType
+enum class IasZoneType : uint16_t
+{
+    IAS_ZONE_TYPE_STANDARD_CIE              = 0x00,
+    IAS_ZONE_TYPE_MOTION_SENSOR             = 0x0D,
+    IAS_ZONE_TYPE_CONTACT_SWITCH            = 0x15,
+    IAS_ZONE_TYPE_FIRE_SENSOR               = 0x28,
+    IAS_ZONE_TYPE_WATER_SENSOR              = 0x2A,
+    IAS_ZONE_TYPE_GAS_SENSOR                = 0x2B,
+    IAS_ZONE_TYPE_PERSONAL_EMERGENCY_DEVICE = 0x2C,
+    IAS_ZONE_TYPE_VIBRATION_MOVEMENT_SENSOR = 0x2D,
+    IAS_ZONE_TYPE_REMOTE_CONTROL            = 0x10F,
+    IAS_ZONE_TYPE_KEY_FOB                   = 0x115,
+    IAS_ZONE_TYPE_KEYPAD                    = 0x21D,
+    IAS_ZONE_TYPE_STANDARD_WARNING_DEVICE   = 0x225,
+    IAS_ZONE_TYPE_GLASS_BREAK_SENSOR        = 0x226,
+    IAS_ZONE_TYPE_CARBON_MONOXIDE_SENSOR    = 0x227,
+    IAS_ZONE_TYPE_SECURITY_REPEATER         = 0x229,
+    IAS_ZONE_TYPE_INVALID_ZONE_TYPE         = 0xFFFF,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasZoneType                          = EmberAfIasZoneType;
+#endif
+
+namespace Commands {
+namespace ZoneEnrollResponse {
+enum class Fields
+{
+    kEnrollResponseCode = 0,
+    kZoneId             = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ZoneEnrollResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    IasEnrollResponseCode enrollResponseCode;
+    uint8_t zoneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ZoneEnrollResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    IasEnrollResponseCode enrollResponseCode;
+    uint8_t zoneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ZoneEnrollResponse
+namespace ZoneStatusChangeNotification {
+enum class Fields
+{
+    kZoneStatus     = 0,
+    kExtendedStatus = 1,
+    kZoneId         = 2,
+    kDelay          = 3,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ZoneStatusChangeNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    uint16_t zoneStatus;
+    uint8_t extendedStatus;
+    uint8_t zoneId;
+    uint16_t delay;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ZoneStatusChangeNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    uint16_t zoneStatus;
+    uint8_t extendedStatus;
+    uint8_t zoneId;
+    uint16_t delay;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ZoneStatusChangeNotification
+namespace InitiateNormalOperationMode {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return InitiateNormalOperationMode::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return InitiateNormalOperationMode::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace InitiateNormalOperationMode
+namespace ZoneEnrollRequest {
+enum class Fields
+{
+    kZoneType         = 0,
+    kManufacturerCode = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ZoneEnrollRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    IasZoneType zoneType;
+    uint16_t manufacturerCode;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ZoneEnrollRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    IasZoneType zoneType;
+    uint16_t manufacturerCode;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ZoneEnrollRequest
+namespace InitiateTestMode {
+enum class Fields
+{
+    kTestModeDuration            = 0,
+    kCurrentZoneSensitivityLevel = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return InitiateTestMode::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    uint8_t testModeDuration;
+    uint8_t currentZoneSensitivityLevel;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return InitiateTestMode::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    uint8_t testModeDuration;
+    uint8_t currentZoneSensitivityLevel;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace InitiateTestMode
+namespace InitiateNormalOperationModeResponse {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return InitiateNormalOperationModeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return InitiateNormalOperationModeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace InitiateNormalOperationModeResponse
+namespace InitiateTestModeResponse {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return InitiateTestModeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return InitiateTestModeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace InitiateTestModeResponse
+} // namespace Commands
+
+namespace Attributes {
+namespace ZoneState {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ZoneState::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ZoneState
+namespace ZoneType {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ZoneType::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ZoneType
+namespace ZoneStatus {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ZoneStatus::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ZoneStatus
+namespace IasCieAddress {
+struct TypeInfo
+{
+    using Type = chip::NodeId;
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::IasCieAddress::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace IasCieAddress
+namespace ZoneId {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ZoneId::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ZoneId
+namespace NumberOfZoneSensitivityLevelsSupported {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfZoneSensitivityLevelsSupported::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace NumberOfZoneSensitivityLevelsSupported
+namespace CurrentZoneSensitivityLevel {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return IasZone::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentZoneSensitivityLevel::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentZoneSensitivityLevel
+} // namespace Attributes
+} // namespace IasZone
+namespace IasAce {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasAceAlarmStatus
+enum class IasAceAlarmStatus : uint8_t
+{
+    IAS_ACE_ALARM_STATUS_NO_ALARM        = 0x00,
+    IAS_ACE_ALARM_STATUS_BURGLAR         = 0x01,
+    IAS_ACE_ALARM_STATUS_FIRE            = 0x02,
+    IAS_ACE_ALARM_STATUS_EMERGENCY       = 0x03,
+    IAS_ACE_ALARM_STATUS_POLICE_PANIC    = 0x04,
+    IAS_ACE_ALARM_STATUS_FIRE_PANIC      = 0x05,
+    IAS_ACE_ALARM_STATUS_EMERGENCY_PANIC = 0x06,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasAceAlarmStatus                    = EmberAfIasAceAlarmStatus;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasAceArmMode
+enum class IasAceArmMode : uint8_t
+{
+    IAS_ACE_ARM_MODE_DISARM                     = 0x00,
+    IAS_ACE_ARM_MODE_ARM_DAY_HOME_ZONES_ONLY    = 0x01,
+    IAS_ACE_ARM_MODE_ARM_NIGHT_SLEEP_ZONES_ONLY = 0x02,
+    IAS_ACE_ARM_MODE_ARM_ALL_ZONES              = 0x03,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasAceArmMode                        = EmberAfIasAceArmMode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasAceArmNotification
+enum class IasAceArmNotification : uint8_t
+{
+    IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_DISARMED           = 0x00,
+    IAS_ACE_ARM_NOTIFICATION_ONLY_DAY_HOME_ZONES_ARMED    = 0x01,
+    IAS_ACE_ARM_NOTIFICATION_ONLY_NIGHT_SLEEP_ZONES_ARMED = 0x02,
+    IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_ARMED              = 0x03,
+    IAS_ACE_ARM_NOTIFICATION_INVALID_ARM_DISARM_CODE      = 0x04,
+    IAS_ACE_ARM_NOTIFICATION_NOT_READY_TO_ARM             = 0x05,
+    IAS_ACE_ARM_NOTIFICATION_ALREADY_DISARMED             = 0x06,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasAceArmNotification                = EmberAfIasAceArmNotification;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasAceAudibleNotification
+enum class IasAceAudibleNotification : uint8_t
+{
+    IAS_ACE_AUDIBLE_NOTIFICATION_MUTE          = 0x00,
+    IAS_ACE_AUDIBLE_NOTIFICATION_DEFAULT_SOUND = 0x01,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasAceAudibleNotification            = EmberAfIasAceAudibleNotification;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasAceBypassResult
+enum class IasAceBypassResult : uint8_t
+{
+    IAS_ACE_BYPASS_RESULT_ZONE_BYPASSED           = 0x00,
+    IAS_ACE_BYPASS_RESULT_ZONE_NOT_BYPASSED       = 0x01,
+    IAS_ACE_BYPASS_RESULT_NOT_ALLOWED             = 0x02,
+    IAS_ACE_BYPASS_RESULT_INVALID_ZONE_ID         = 0x03,
+    IAS_ACE_BYPASS_RESULT_UNKNOWN_ZONE_ID         = 0x04,
+    IAS_ACE_BYPASS_RESULT_INVALID_ARM_DISARM_CODE = 0x05,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasAceBypassResult                   = EmberAfIasAceBypassResult;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasAcePanelStatus
+enum class IasAcePanelStatus : uint8_t
+{
+    IAS_ACE_PANEL_STATUS_PANEL_DISARMED   = 0x00,
+    IAS_ACE_PANEL_STATUS_ARMED_STAY       = 0x01,
+    IAS_ACE_PANEL_STATUS_ARMED_NIGHT      = 0x02,
+    IAS_ACE_PANEL_STATUS_ARMED_AWAY       = 0x03,
+    IAS_ACE_PANEL_STATUS_EXIT_DELAY       = 0x04,
+    IAS_ACE_PANEL_STATUS_ENTRY_DELAY      = 0x05,
+    IAS_ACE_PANEL_STATUS_NOT_READY_TO_ARM = 0x06,
+    IAS_ACE_PANEL_STATUS_IN_ALARM         = 0x07,
+    IAS_ACE_PANEL_STATUS_ARMING_STAY      = 0x08,
+    IAS_ACE_PANEL_STATUS_ARMING_NIGHT     = 0x09,
+    IAS_ACE_PANEL_STATUS_ARMING_AWAY      = 0x0A,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasAcePanelStatus                    = EmberAfIasAcePanelStatus;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for IasZoneType
+enum class IasZoneType : uint16_t
+{
+    IAS_ZONE_TYPE_STANDARD_CIE              = 0x00,
+    IAS_ZONE_TYPE_MOTION_SENSOR             = 0x0D,
+    IAS_ZONE_TYPE_CONTACT_SWITCH            = 0x15,
+    IAS_ZONE_TYPE_FIRE_SENSOR               = 0x28,
+    IAS_ZONE_TYPE_WATER_SENSOR              = 0x2A,
+    IAS_ZONE_TYPE_GAS_SENSOR                = 0x2B,
+    IAS_ZONE_TYPE_PERSONAL_EMERGENCY_DEVICE = 0x2C,
+    IAS_ZONE_TYPE_VIBRATION_MOVEMENT_SENSOR = 0x2D,
+    IAS_ZONE_TYPE_REMOTE_CONTROL            = 0x10F,
+    IAS_ZONE_TYPE_KEY_FOB                   = 0x115,
+    IAS_ZONE_TYPE_KEYPAD                    = 0x21D,
+    IAS_ZONE_TYPE_STANDARD_WARNING_DEVICE   = 0x225,
+    IAS_ZONE_TYPE_GLASS_BREAK_SENSOR        = 0x226,
+    IAS_ZONE_TYPE_CARBON_MONOXIDE_SENSOR    = 0x227,
+    IAS_ZONE_TYPE_SECURITY_REPEATER         = 0x229,
+    IAS_ZONE_TYPE_INVALID_ZONE_TYPE         = 0xFFFF,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using IasZoneType                          = EmberAfIasZoneType;
+#endif
+
+namespace Structs {
+namespace IasAceZoneStatusResult {
+enum class Fields
+{
+    kZoneId     = 0,
+    kZoneStatus = 1,
+};
+
+struct Type
+{
+public:
+    uint8_t zoneId;
+    uint16_t zoneStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace IasAceZoneStatusResult
+} // namespace Structs
+
+namespace Commands {
+namespace Arm {
+enum class Fields
+{
+    kArmMode       = 0,
+    kArmDisarmCode = 1,
+    kZoneId        = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Arm::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    IasAceArmMode armMode;
+    Span<const char> armDisarmCode;
+    uint8_t zoneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Arm::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    IasAceArmMode armMode;
+    Span<const char> armDisarmCode;
+    uint8_t zoneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Arm
+namespace ArmResponse {
+enum class Fields
+{
+    kArmNotification = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ArmResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    IasAceArmNotification armNotification;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ArmResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    IasAceArmNotification armNotification;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ArmResponse
+namespace Bypass {
+enum class Fields
+{
+    kNumberOfZones = 0,
+    kZoneIds       = 1,
+    kArmDisarmCode = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Bypass::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t numberOfZones;
+    DataModel::List<uint8_t> zoneIds;
+    Span<const char> armDisarmCode;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Bypass::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t numberOfZones;
+    DataModel::DecodableList<uint8_t> zoneIds;
+    Span<const char> armDisarmCode;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Bypass
+namespace GetZoneIdMapResponse {
+enum class Fields
+{
+    kSection0  = 0,
+    kSection1  = 1,
+    kSection2  = 2,
+    kSection3  = 3,
+    kSection4  = 4,
+    kSection5  = 5,
+    kSection6  = 6,
+    kSection7  = 7,
+    kSection8  = 8,
+    kSection9  = 9,
+    kSection10 = 10,
+    kSection11 = 11,
+    kSection12 = 12,
+    kSection13 = 13,
+    kSection14 = 14,
+    kSection15 = 15,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetZoneIdMapResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint16_t section0;
+    uint16_t section1;
+    uint16_t section2;
+    uint16_t section3;
+    uint16_t section4;
+    uint16_t section5;
+    uint16_t section6;
+    uint16_t section7;
+    uint16_t section8;
+    uint16_t section9;
+    uint16_t section10;
+    uint16_t section11;
+    uint16_t section12;
+    uint16_t section13;
+    uint16_t section14;
+    uint16_t section15;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetZoneIdMapResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint16_t section0;
+    uint16_t section1;
+    uint16_t section2;
+    uint16_t section3;
+    uint16_t section4;
+    uint16_t section5;
+    uint16_t section6;
+    uint16_t section7;
+    uint16_t section8;
+    uint16_t section9;
+    uint16_t section10;
+    uint16_t section11;
+    uint16_t section12;
+    uint16_t section13;
+    uint16_t section14;
+    uint16_t section15;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetZoneIdMapResponse
+namespace Emergency {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Emergency::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Emergency::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Emergency
+namespace GetZoneInformationResponse {
+enum class Fields
+{
+    kZoneId      = 0,
+    kZoneType    = 1,
+    kIeeeAddress = 2,
+    kZoneLabel   = 3,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetZoneInformationResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t zoneId;
+    IasZoneType zoneType;
+    chip::NodeId ieeeAddress;
+    Span<const char> zoneLabel;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetZoneInformationResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t zoneId;
+    IasZoneType zoneType;
+    chip::NodeId ieeeAddress;
+    Span<const char> zoneLabel;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetZoneInformationResponse
+namespace Fire {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Fire::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Fire::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Fire
+namespace ZoneStatusChanged {
+enum class Fields
+{
+    kZoneId              = 0,
+    kZoneStatus          = 1,
+    kAudibleNotification = 2,
+    kZoneLabel           = 3,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ZoneStatusChanged::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t zoneId;
+    uint16_t zoneStatus;
+    IasAceAudibleNotification audibleNotification;
+    Span<const char> zoneLabel;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ZoneStatusChanged::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t zoneId;
+    uint16_t zoneStatus;
+    IasAceAudibleNotification audibleNotification;
+    Span<const char> zoneLabel;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ZoneStatusChanged
+namespace Panic {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Panic::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Panic::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Panic
+namespace PanelStatusChanged {
+enum class Fields
+{
+    kPanelStatus         = 0,
+    kSecondsRemaining    = 1,
+    kAudibleNotification = 2,
+    kAlarmStatus         = 3,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PanelStatusChanged::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    IasAcePanelStatus panelStatus;
+    uint8_t secondsRemaining;
+    IasAceAudibleNotification audibleNotification;
+    IasAceAlarmStatus alarmStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return PanelStatusChanged::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    IasAcePanelStatus panelStatus;
+    uint8_t secondsRemaining;
+    IasAceAudibleNotification audibleNotification;
+    IasAceAlarmStatus alarmStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PanelStatusChanged
+namespace GetZoneIdMap {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetZoneIdMap::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetZoneIdMap::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetZoneIdMap
+namespace GetPanelStatusResponse {
+enum class Fields
+{
+    kPanelStatus         = 0,
+    kSecondsRemaining    = 1,
+    kAudibleNotification = 2,
+    kAlarmStatus         = 3,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetPanelStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    IasAcePanelStatus panelStatus;
+    uint8_t secondsRemaining;
+    IasAceAudibleNotification audibleNotification;
+    IasAceAlarmStatus alarmStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetPanelStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    IasAcePanelStatus panelStatus;
+    uint8_t secondsRemaining;
+    IasAceAudibleNotification audibleNotification;
+    IasAceAlarmStatus alarmStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPanelStatusResponse
+namespace GetZoneInformation {
+enum class Fields
+{
+    kZoneId = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetZoneInformation::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t zoneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetZoneInformation::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t zoneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetZoneInformation
+namespace SetBypassedZoneList {
+enum class Fields
+{
+    kNumberOfZones = 0,
+    kZoneIds       = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SetBypassedZoneList::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t numberOfZones;
+    DataModel::List<uint8_t> zoneIds;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SetBypassedZoneList::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t numberOfZones;
+    DataModel::DecodableList<uint8_t> zoneIds;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetBypassedZoneList
+namespace GetPanelStatus {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetPanelStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetPanelStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPanelStatus
+namespace BypassResponse {
+enum class Fields
+{
+    kNumberOfZones = 0,
+    kBypassResult  = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return BypassResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t numberOfZones;
+    DataModel::List<IasAceBypassResult> bypassResult;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return BypassResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t numberOfZones;
+    DataModel::DecodableList<IasAceBypassResult> bypassResult;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace BypassResponse
+namespace GetBypassedZoneList {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetBypassedZoneList::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetBypassedZoneList::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetBypassedZoneList
+namespace GetZoneStatusResponse {
+enum class Fields
+{
+    kZoneStatusComplete = 0,
+    kNumberOfZones      = 1,
+    kZoneStatusResult   = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetZoneStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    bool zoneStatusComplete;
+    uint8_t numberOfZones;
+    DataModel::List<Structs::IasAceZoneStatusResult::Type> zoneStatusResult;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetZoneStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    bool zoneStatusComplete;
+    uint8_t numberOfZones;
+    DataModel::DecodableList<Structs::IasAceZoneStatusResult::DecodableType> zoneStatusResult;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetZoneStatusResponse
+namespace GetZoneStatus {
+enum class Fields
+{
+    kStartingZoneId     = 0,
+    kMaxNumberOfZoneIds = 1,
+    kZoneStatusMaskFlag = 2,
+    kZoneStatusMask     = 3,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetZoneStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t startingZoneId;
+    uint8_t maxNumberOfZoneIds;
+    bool zoneStatusMaskFlag;
+    uint16_t zoneStatusMask;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetZoneStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
+
+    uint8_t startingZoneId;
+    uint8_t maxNumberOfZoneIds;
+    bool zoneStatusMaskFlag;
+    uint16_t zoneStatusMask;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetZoneStatus
+} // namespace Commands
+
+} // namespace IasAce
+namespace IasWd {
+
+namespace Commands {
+namespace StartWarning {
+enum class Fields
+{
+    kWarningInfo     = 0,
+    kWarningDuration = 1,
+    kStrobeDutyCycle = 2,
+    kStrobeLevel     = 3,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return StartWarning::Id; }
+    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
+
+    uint8_t warningInfo;
+    uint16_t warningDuration;
+    uint8_t strobeDutyCycle;
+    uint8_t strobeLevel;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return StartWarning::Id; }
+    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
+
+    uint8_t warningInfo;
+    uint16_t warningDuration;
+    uint8_t strobeDutyCycle;
+    uint8_t strobeLevel;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StartWarning
+namespace Squawk {
+enum class Fields
+{
+    kSquawkInfo = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Squawk::Id; }
+    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
+
+    uint8_t squawkInfo;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Squawk::Id; }
+    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
+
+    uint8_t squawkInfo;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Squawk
+} // namespace Commands
+
+namespace Attributes {
+namespace MaxDuration {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return IasWd::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MaxDuration::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MaxDuration
+} // namespace Attributes
+} // namespace IasWd
+namespace WakeOnLan {
+
+namespace Attributes {
+namespace WakeOnLanMacAddress {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return WakeOnLan::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::WakeOnLanMacAddress::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace WakeOnLanMacAddress
+} // namespace Attributes
+} // namespace WakeOnLan
+namespace TvChannel {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for TvChannelErrorType
+enum class TvChannelErrorType : uint8_t
+{
+    TV_CHANNEL_ERROR_TYPE_MULTIPLE_MATCHES = 0x00,
+    TV_CHANNEL_ERROR_TYPE_NO_MATCHES       = 0x01,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using TvChannelErrorType                   = EmberAfTvChannelErrorType;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for TvChannelLineupInfoType
+enum class TvChannelLineupInfoType : uint8_t
+{
+    TV_CHANNEL_LINEUP_INFO_TYPE_MSO = 0x00,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using TvChannelLineupInfoType              = EmberAfTvChannelLineupInfoType;
+#endif
+
+namespace Structs {
+namespace TvChannelInfo {
+enum class Fields
+{
+    kMajorNumber       = 0,
+    kMinorNumber       = 1,
+    kName              = 2,
+    kCallSign          = 3,
+    kAffiliateCallSign = 4,
+};
+
+struct Type
+{
+public:
+    uint16_t majorNumber;
+    uint16_t minorNumber;
+    chip::ByteSpan name;
+    chip::ByteSpan callSign;
+    chip::ByteSpan affiliateCallSign;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace TvChannelInfo
+namespace TvChannelLineupInfo {
+enum class Fields
+{
+    kOperatorName   = 0,
+    kLineupName     = 1,
+    kPostalCode     = 2,
+    kLineupInfoType = 3,
+};
+
+struct Type
+{
+public:
+    Span<const char> operatorName;
+    Span<const char> lineupName;
+    Span<const char> postalCode;
+    TvChannelLineupInfoType lineupInfoType;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace TvChannelLineupInfo
+} // namespace Structs
+
+namespace Commands {
+namespace ChangeChannel {
+enum class Fields
+{
+    kMatch = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ChangeChannel::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+
+    Span<const char> match;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ChangeChannel::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+
+    Span<const char> match;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeChannel
+namespace ChangeChannelResponse {
+enum class Fields
+{
+    kChannelMatch = 0,
+    kErrorType    = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ChangeChannelResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+
+    DataModel::List<Structs::TvChannelInfo::Type> channelMatch;
+    TvChannelErrorType errorType;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ChangeChannelResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+
+    DataModel::DecodableList<Structs::TvChannelInfo::DecodableType> channelMatch;
+    TvChannelErrorType errorType;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeChannelResponse
+namespace ChangeChannelByNumber {
+enum class Fields
+{
+    kMajorNumber = 0,
+    kMinorNumber = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ChangeChannelByNumber::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+
+    uint16_t majorNumber;
+    uint16_t minorNumber;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ChangeChannelByNumber::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+
+    uint16_t majorNumber;
+    uint16_t minorNumber;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeChannelByNumber
+namespace SkipChannel {
+enum class Fields
+{
+    kCount = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SkipChannel::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+
+    uint16_t count;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SkipChannel::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+
+    uint16_t count;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SkipChannel
+} // namespace Commands
+
+namespace Attributes {
+namespace TvChannelList {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::TvChannelInfo::Type>;
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TvChannelList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::TvChannelInfo::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TvChannelList::Id; }
+};
+} // namespace TvChannelList
+namespace TvChannelLineup {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TvChannelLineup::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace TvChannelLineup
+namespace CurrentTvChannel {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentTvChannel::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentTvChannel
+} // namespace Attributes
+} // namespace TvChannel
+namespace TargetNavigator {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for NavigateTargetStatus
+enum class NavigateTargetStatus : uint8_t
+{
+    NAVIGATE_TARGET_STATUS_SUCCESS           = 0x00,
+    NAVIGATE_TARGET_STATUS_APP_NOT_AVAILABLE = 0x01,
+    NAVIGATE_TARGET_STATUS_SYSTEM_BUSY       = 0x02,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using NavigateTargetStatus                 = EmberAfNavigateTargetStatus;
+#endif
+
+namespace Structs {
+namespace NavigateTargetTargetInfo {
+enum class Fields
+{
+    kIdentifier = 0,
+    kName       = 1,
+};
+
+struct Type
+{
+public:
+    uint8_t identifier;
+    chip::ByteSpan name;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace NavigateTargetTargetInfo
+} // namespace Structs
+
+namespace Commands {
+namespace NavigateTarget {
+enum class Fields
+{
+    kTarget = 0,
+    kData   = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return NavigateTarget::Id; }
+    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+
+    uint8_t target;
+    Span<const char> data;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return NavigateTarget::Id; }
+    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+
+    uint8_t target;
+    Span<const char> data;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NavigateTarget
+namespace NavigateTargetResponse {
+enum class Fields
+{
+    kStatus = 0,
+    kData   = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return NavigateTargetResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+
+    NavigateTargetStatus status;
+    Span<const char> data;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return NavigateTargetResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+
+    NavigateTargetStatus status;
+    Span<const char> data;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NavigateTargetResponse
+} // namespace Commands
+
+namespace Attributes {
+namespace TargetNavigatorList {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::NavigateTargetTargetInfo::Type>;
+    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TargetNavigatorList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::NavigateTargetTargetInfo::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TargetNavigatorList::Id; }
+};
+} // namespace TargetNavigatorList
+namespace CurrentNavigatorTarget {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return TargetNavigator::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentNavigatorTarget::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentNavigatorTarget
+} // namespace Attributes
+} // namespace TargetNavigator
+namespace MediaPlayback {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for MediaPlaybackState
+enum class MediaPlaybackState : uint8_t
+{
+    MEDIA_PLAYBACK_STATE_PLAYING     = 0x00,
+    MEDIA_PLAYBACK_STATE_PAUSED      = 0x01,
+    MEDIA_PLAYBACK_STATE_NOT_PLAYING = 0x02,
+    MEDIA_PLAYBACK_STATE_BUFFERING   = 0x03,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using MediaPlaybackState                   = EmberAfMediaPlaybackState;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for MediaPlaybackStatus
+enum class MediaPlaybackStatus : uint8_t
+{
+    MEDIA_PLAYBACK_STATUS_SUCCESS                   = 0x00,
+    MEDIA_PLAYBACK_STATUS_INVALID_STATE_FOR_COMMAND = 0x01,
+    MEDIA_PLAYBACK_STATUS_NOT_ALLOWED               = 0x02,
+    MEDIA_PLAYBACK_STATUS_NOT_ACTIVE                = 0x03,
+    MEDIA_PLAYBACK_STATUS_SPEED_OUT_OF_RANGE        = 0x04,
+    MEDIA_PLAYBACK_STATUS_SEEK_OUT_OF_RANGE         = 0x05,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using MediaPlaybackStatus                  = EmberAfMediaPlaybackStatus;
+#endif
+
+namespace Structs {
+namespace MediaPlaybackPosition {
+enum class Fields
+{
+    kUpdatedAt = 0,
+    kPosition  = 1,
+};
+
+struct Type
+{
+public:
+    uint64_t updatedAt;
+    uint64_t position;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace MediaPlaybackPosition
+} // namespace Structs
+
+namespace Commands {
+namespace MediaPlay {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaPlay::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaPlay::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaPlay
+namespace MediaPlayResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaPlayResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaPlayResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaPlayResponse
+namespace MediaPause {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaPause::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaPause::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaPause
+namespace MediaPauseResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaPauseResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaPauseResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaPauseResponse
+namespace MediaStop {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaStop::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaStop::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaStop
+namespace MediaStopResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaStopResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaStopResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaStopResponse
+namespace MediaStartOver {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaStartOver::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaStartOver::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaStartOver
+namespace MediaStartOverResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaStartOverResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaStartOverResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaStartOverResponse
+namespace MediaPrevious {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaPrevious::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaPrevious::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaPrevious
+namespace MediaPreviousResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaPreviousResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaPreviousResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaPreviousResponse
+namespace MediaNext {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaNext::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaNext::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaNext
+namespace MediaNextResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaNextResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaNextResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaNextResponse
+namespace MediaRewind {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaRewind::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaRewind::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaRewind
+namespace MediaRewindResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaRewindResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaRewindResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaRewindResponse
+namespace MediaFastForward {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaFastForward::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaFastForward::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaFastForward
+namespace MediaFastForwardResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaFastForwardResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaFastForwardResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaFastForwardResponse
+namespace MediaSkipForward {
+enum class Fields
+{
+    kDeltaPositionMilliseconds = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaSkipForward::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    uint64_t deltaPositionMilliseconds;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaSkipForward::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    uint64_t deltaPositionMilliseconds;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaSkipForward
+namespace MediaSkipForwardResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaSkipForwardResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaSkipForwardResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaSkipForwardResponse
+namespace MediaSkipBackward {
+enum class Fields
+{
+    kDeltaPositionMilliseconds = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaSkipBackward::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    uint64_t deltaPositionMilliseconds;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaSkipBackward::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    uint64_t deltaPositionMilliseconds;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaSkipBackward
+namespace MediaSkipBackwardResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaSkipBackwardResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaSkipBackwardResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaSkipBackwardResponse
+namespace MediaSeek {
+enum class Fields
+{
+    kPosition = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaSeek::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    uint64_t position;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaSeek::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    uint64_t position;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaSeek
+namespace MediaSeekResponse {
+enum class Fields
+{
+    kMediaPlaybackStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MediaSeekResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return MediaSeekResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+
+    MediaPlaybackStatus mediaPlaybackStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MediaSeekResponse
+} // namespace Commands
+
+namespace Attributes {
+namespace PlaybackState {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PlaybackState::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PlaybackState
+namespace StartTime {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::StartTime::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace StartTime
+namespace Duration {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Duration::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Duration
+namespace PositionUpdatedAt {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PositionUpdatedAt::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PositionUpdatedAt
+namespace Position {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Position::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Position
+namespace PlaybackSpeed {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PlaybackSpeed::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PlaybackSpeed
+namespace SeekRangeEnd {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SeekRangeEnd::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SeekRangeEnd
+namespace SeekRangeStart {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return MediaPlayback::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SeekRangeStart::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace SeekRangeStart
+} // namespace Attributes
+} // namespace MediaPlayback
+namespace MediaInput {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for MediaInputType
+enum class MediaInputType : uint8_t
+{
+    MEDIA_INPUT_TYPE_INTERNAL  = 0x00,
+    MEDIA_INPUT_TYPE_AUX       = 0x01,
+    MEDIA_INPUT_TYPE_COAX      = 0x02,
+    MEDIA_INPUT_TYPE_COMPOSITE = 0x03,
+    MEDIA_INPUT_TYPE_HDMI      = 0x04,
+    MEDIA_INPUT_TYPE_INPUT     = 0x05,
+    MEDIA_INPUT_TYPE_LINE      = 0x06,
+    MEDIA_INPUT_TYPE_OPTICAL   = 0x07,
+    MEDIA_INPUT_TYPE_VIDEO     = 0x08,
+    MEDIA_INPUT_TYPE_SCART     = 0x09,
+    MEDIA_INPUT_TYPE_USB       = 0x0A,
+    MEDIA_INPUT_TYPE_OTHER     = 0x0B,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using MediaInputType                       = EmberAfMediaInputType;
+#endif
+
+namespace Structs {
+namespace MediaInputInfo {
+enum class Fields
+{
+    kIndex       = 0,
+    kInputType   = 1,
+    kName        = 2,
+    kDescription = 3,
+};
+
+struct Type
+{
+public:
+    uint8_t index;
+    MediaInputType inputType;
+    chip::ByteSpan name;
+    chip::ByteSpan description;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace MediaInputInfo
+} // namespace Structs
+
+namespace Commands {
+namespace SelectInput {
+enum class Fields
+{
+    kIndex = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SelectInput::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+
+    uint8_t index;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SelectInput::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+
+    uint8_t index;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SelectInput
+namespace ShowInputStatus {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ShowInputStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ShowInputStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ShowInputStatus
+namespace HideInputStatus {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return HideInputStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return HideInputStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace HideInputStatus
+namespace RenameInput {
+enum class Fields
+{
+    kIndex = 0,
+    kName  = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RenameInput::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+
+    uint8_t index;
+    Span<const char> name;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return RenameInput::Id; }
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+
+    uint8_t index;
+    Span<const char> name;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RenameInput
+} // namespace Commands
+
+namespace Attributes {
+namespace MediaInputList {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::MediaInputInfo::Type>;
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MediaInputList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::MediaInputInfo::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MediaInputList::Id; }
+};
+} // namespace MediaInputList
+namespace CurrentMediaInput {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return MediaInput::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMediaInput::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentMediaInput
+} // namespace Attributes
+} // namespace MediaInput
+namespace LowPower {
+
+namespace Commands {
+namespace Sleep {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Sleep::Id; }
+    static constexpr ClusterId GetClusterId() { return LowPower::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Sleep::Id; }
+    static constexpr ClusterId GetClusterId() { return LowPower::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Sleep
+} // namespace Commands
+
 } // namespace LowPower
 namespace KeypadInput {
 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for KeypadInputCecKeyCode
-enum class KeypadInputCecKeyCode : uint8_t
+// Enum for KeypadInputCecKeyCode
+enum class KeypadInputCecKeyCode : uint8_t
+{
+    KEYPAD_INPUT_CEC_KEY_CODE_SELECT                       = 0x00,
+    KEYPAD_INPUT_CEC_KEY_CODE_UP                           = 0x01,
+    KEYPAD_INPUT_CEC_KEY_CODE_DOWN                         = 0x02,
+    KEYPAD_INPUT_CEC_KEY_CODE_LEFT                         = 0x03,
+    KEYPAD_INPUT_CEC_KEY_CODE_RIGHT                        = 0x04,
+    KEYPAD_INPUT_CEC_KEY_CODE_RIGHT_UP                     = 0x05,
+    KEYPAD_INPUT_CEC_KEY_CODE_RIGHT_DOWN                   = 0x06,
+    KEYPAD_INPUT_CEC_KEY_CODE_LEFT_UP                      = 0x07,
+    KEYPAD_INPUT_CEC_KEY_CODE_LEFT_DOWN                    = 0x08,
+    KEYPAD_INPUT_CEC_KEY_CODE_ROOT_MENU                    = 0x09,
+    KEYPAD_INPUT_CEC_KEY_CODE_SETUP_MENU                   = 0x0A,
+    KEYPAD_INPUT_CEC_KEY_CODE_CONTENTS_MENU                = 0x0B,
+    KEYPAD_INPUT_CEC_KEY_CODE_FAVORITE_MENU                = 0x0C,
+    KEYPAD_INPUT_CEC_KEY_CODE_EXIT                         = 0x0D,
+    KEYPAD_INPUT_CEC_KEY_CODE_MEDIA_TOP_MENU               = 0x10,
+    KEYPAD_INPUT_CEC_KEY_CODE_MEDIA_CONTEXT_SENSITIVE_MENU = 0x11,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBER_ENTRY_MODE            = 0x1D,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBER11                     = 0x1E,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBER12                     = 0x1F,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBER0_OR_NUMBER10          = 0x20,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS1                     = 0x21,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS2                     = 0x22,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS3                     = 0x23,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS4                     = 0x24,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS5                     = 0x25,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS6                     = 0x26,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS7                     = 0x27,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS8                     = 0x28,
+    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS9                     = 0x29,
+    KEYPAD_INPUT_CEC_KEY_CODE_DOT                          = 0x2A,
+    KEYPAD_INPUT_CEC_KEY_CODE_ENTER                        = 0x2B,
+    KEYPAD_INPUT_CEC_KEY_CODE_CLEAR                        = 0x2C,
+    KEYPAD_INPUT_CEC_KEY_CODE_NEXT_FAVORITE                = 0x2F,
+    KEYPAD_INPUT_CEC_KEY_CODE_CHANNEL_UP                   = 0x30,
+    KEYPAD_INPUT_CEC_KEY_CODE_CHANNEL_DOWN                 = 0x31,
+    KEYPAD_INPUT_CEC_KEY_CODE_PREVIOUS_CHANNEL             = 0x32,
+    KEYPAD_INPUT_CEC_KEY_CODE_SOUND_SELECT                 = 0x33,
+    KEYPAD_INPUT_CEC_KEY_CODE_INPUT_SELECT                 = 0x34,
+    KEYPAD_INPUT_CEC_KEY_CODE_DISPLAY_INFORMATION          = 0x35,
+    KEYPAD_INPUT_CEC_KEY_CODE_HELP                         = 0x36,
+    KEYPAD_INPUT_CEC_KEY_CODE_PAGE_UP                      = 0x37,
+    KEYPAD_INPUT_CEC_KEY_CODE_PAGE_DOWN                    = 0x38,
+    KEYPAD_INPUT_CEC_KEY_CODE_POWER                        = 0x40,
+    KEYPAD_INPUT_CEC_KEY_CODE_VOLUME_UP                    = 0x41,
+    KEYPAD_INPUT_CEC_KEY_CODE_VOLUME_DOWN                  = 0x42,
+    KEYPAD_INPUT_CEC_KEY_CODE_MUTE                         = 0x43,
+    KEYPAD_INPUT_CEC_KEY_CODE_PLAY                         = 0x44,
+    KEYPAD_INPUT_CEC_KEY_CODE_STOP                         = 0x45,
+    KEYPAD_INPUT_CEC_KEY_CODE_PAUSE                        = 0x46,
+    KEYPAD_INPUT_CEC_KEY_CODE_RECORD                       = 0x47,
+    KEYPAD_INPUT_CEC_KEY_CODE_REWIND                       = 0x48,
+    KEYPAD_INPUT_CEC_KEY_CODE_FAST_FORWARD                 = 0x49,
+    KEYPAD_INPUT_CEC_KEY_CODE_EJECT                        = 0x4A,
+    KEYPAD_INPUT_CEC_KEY_CODE_FORWARD                      = 0x4B,
+    KEYPAD_INPUT_CEC_KEY_CODE_BACKWARD                     = 0x4C,
+    KEYPAD_INPUT_CEC_KEY_CODE_STOP_RECORD                  = 0x4D,
+    KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_RECORD                 = 0x4E,
+    KEYPAD_INPUT_CEC_KEY_CODE_RESERVED                     = 0x4F,
+    KEYPAD_INPUT_CEC_KEY_CODE_ANGLE                        = 0x50,
+    KEYPAD_INPUT_CEC_KEY_CODE_SUB_PICTURE                  = 0x51,
+    KEYPAD_INPUT_CEC_KEY_CODE_VIDEO_ON_DEMAND              = 0x52,
+    KEYPAD_INPUT_CEC_KEY_CODE_ELECTRONIC_PROGRAM_GUIDE     = 0x53,
+    KEYPAD_INPUT_CEC_KEY_CODE_TIMER_PROGRAMMING            = 0x54,
+    KEYPAD_INPUT_CEC_KEY_CODE_INITIAL_CONFIGURATION        = 0x55,
+    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_BROADCAST_TYPE        = 0x56,
+    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_SOUND_PRESENTATION    = 0x57,
+    KEYPAD_INPUT_CEC_KEY_CODE_PLAY_FUNCTION                = 0x60,
+    KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_PLAY_FUNCTION          = 0x61,
+    KEYPAD_INPUT_CEC_KEY_CODE_RECORD_FUNCTION              = 0x62,
+    KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_RECORD_FUNCTION        = 0x63,
+    KEYPAD_INPUT_CEC_KEY_CODE_STOP_FUNCTION                = 0x64,
+    KEYPAD_INPUT_CEC_KEY_CODE_MUTE_FUNCTION                = 0x65,
+    KEYPAD_INPUT_CEC_KEY_CODE_RESTORE_VOLUME_FUNCTION      = 0x66,
+    KEYPAD_INPUT_CEC_KEY_CODE_TUNE_FUNCTION                = 0x67,
+    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_MEDIA_FUNCTION        = 0x68,
+    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_AV_INPUT_FUNCTION     = 0x69,
+    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_AUDIO_INPUT_FUNCTION  = 0x6A,
+    KEYPAD_INPUT_CEC_KEY_CODE_POWER_TOGGLE_FUNCTION        = 0x6B,
+    KEYPAD_INPUT_CEC_KEY_CODE_POWER_OFF_FUNCTION           = 0x6C,
+    KEYPAD_INPUT_CEC_KEY_CODE_POWER_ON_FUNCTION            = 0x6D,
+    KEYPAD_INPUT_CEC_KEY_CODE_F1_BLUE                      = 0x71,
+    KEYPAD_INPUT_CEC_KEY_CODE_F2_RED                       = 0x72,
+    KEYPAD_INPUT_CEC_KEY_CODE_F3_GREEN                     = 0x73,
+    KEYPAD_INPUT_CEC_KEY_CODE_F4_YELLOW                    = 0x74,
+    KEYPAD_INPUT_CEC_KEY_CODE_F5                           = 0x75,
+    KEYPAD_INPUT_CEC_KEY_CODE_DATA                         = 0x76,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using KeypadInputCecKeyCode                = EmberAfKeypadInputCecKeyCode;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for KeypadInputStatus
+enum class KeypadInputStatus : uint8_t
+{
+    KEYPAD_INPUT_STATUS_SUCCESS                      = 0x00,
+    KEYPAD_INPUT_STATUS_UNSUPPORTED_KEY              = 0x01,
+    KEYPAD_INPUT_STATUS_INVALID_KEY_IN_CURRENT_STATE = 0x02,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using KeypadInputStatus                    = EmberAfKeypadInputStatus;
+#endif
+
+namespace Commands {
+namespace SendKey {
+enum class Fields
+{
+    kKeyCode = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SendKey::Id; }
+    static constexpr ClusterId GetClusterId() { return KeypadInput::Id; }
+
+    KeypadInputCecKeyCode keyCode;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SendKey::Id; }
+    static constexpr ClusterId GetClusterId() { return KeypadInput::Id; }
+
+    KeypadInputCecKeyCode keyCode;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SendKey
+namespace SendKeyResponse {
+enum class Fields
+{
+    kStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SendKeyResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return KeypadInput::Id; }
+
+    KeypadInputStatus status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SendKeyResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return KeypadInput::Id; }
+
+    KeypadInputStatus status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SendKeyResponse
+} // namespace Commands
+
+} // namespace KeypadInput
+namespace ContentLauncher {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for ContentLaunchMetricType
+enum class ContentLaunchMetricType : uint8_t
+{
+    CONTENT_LAUNCH_METRIC_TYPE_PIXELS     = 0x00,
+    CONTENT_LAUNCH_METRIC_TYPE_PERCENTAGE = 0x01,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using ContentLaunchMetricType              = EmberAfContentLaunchMetricType;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for ContentLaunchParameterEnum
+enum class ContentLaunchParameterEnum : uint8_t
+{
+    CONTENT_LAUNCH_PARAMETER_ENUM_ACTOR       = 0x00,
+    CONTENT_LAUNCH_PARAMETER_ENUM_CHANNEL     = 0x01,
+    CONTENT_LAUNCH_PARAMETER_ENUM_CHARACTER   = 0x02,
+    CONTENT_LAUNCH_PARAMETER_ENUM_EVENT       = 0x03,
+    CONTENT_LAUNCH_PARAMETER_ENUM_FRANCHISE   = 0x04,
+    CONTENT_LAUNCH_PARAMETER_ENUM_GENRE       = 0x05,
+    CONTENT_LAUNCH_PARAMETER_ENUM_LEAGUE      = 0x06,
+    CONTENT_LAUNCH_PARAMETER_ENUM_POPULARITY  = 0x07,
+    CONTENT_LAUNCH_PARAMETER_ENUM_SPORT       = 0x08,
+    CONTENT_LAUNCH_PARAMETER_ENUM_SPORTS_TEAM = 0x09,
+    CONTENT_LAUNCH_PARAMETER_ENUM_VIDEO       = 0x0A,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using ContentLaunchParameterEnum           = EmberAfContentLaunchParameterEnum;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for ContentLaunchStatus
+enum class ContentLaunchStatus : uint8_t
+{
+    CONTENT_LAUNCH_STATUS_SUCCESS           = 0x00,
+    CONTENT_LAUNCH_STATUS_URL_NOT_AVAILABLE = 0x01,
+    CONTENT_LAUNCH_STATUS_AUTH_FAILED       = 0x02,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using ContentLaunchStatus                  = EmberAfContentLaunchStatus;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for ContentLaunchStreamingType
+enum class ContentLaunchStreamingType : uint8_t
+{
+    CONTENT_LAUNCH_STREAMING_TYPE_DASH = 0x00,
+    CONTENT_LAUNCH_STREAMING_TYPE_HLS  = 0x01,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using ContentLaunchStreamingType           = EmberAfContentLaunchStreamingType;
+#endif
+
+namespace Structs {
+namespace ContentLaunchAdditionalInfo {
+enum class Fields
+{
+    kName  = 0,
+    kValue = 1,
+};
+
+struct Type
+{
+public:
+    Span<const char> name;
+    Span<const char> value;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace ContentLaunchAdditionalInfo
+namespace ContentLaunchParamater {
+enum class Fields
+{
+    kType           = 0,
+    kValue          = 1,
+    kExternalIDList = 2,
+};
+
+struct Type
+{
+public:
+    ContentLaunchParameterEnum type;
+    Span<const char> value;
+    DataModel::List<Structs::ContentLaunchAdditionalInfo::Type> externalIDList;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    ContentLaunchParameterEnum type;
+    Span<const char> value;
+    DataModel::DecodableList<Structs::ContentLaunchAdditionalInfo::DecodableType> externalIDList;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+} // namespace ContentLaunchParamater
+namespace ContentLaunchBrandingInformation {
+enum class Fields
+{
+    kProviderName = 0,
+    kBackground   = 1,
+    kLogo         = 2,
+    kProgressBar  = 3,
+    kSplash       = 4,
+    kWaterMark    = 5,
+};
+
+struct Type
+{
+public:
+    Span<const char> providerName;
+    uint8_t background;
+    uint8_t logo;
+    uint8_t progressBar;
+    uint8_t splash;
+    uint8_t waterMark;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace ContentLaunchBrandingInformation
+namespace ContentLaunchDimension {
+enum class Fields
+{
+    kWidth  = 0,
+    kHeight = 1,
+    kMetric = 2,
+};
+
+struct Type
+{
+public:
+    Span<const char> width;
+    Span<const char> height;
+    ContentLaunchMetricType metric;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace ContentLaunchDimension
+namespace ContentLaunchStyleInformation {
+enum class Fields
+{
+    kImageUrl = 0,
+    kColor    = 1,
+    kSize     = 2,
+};
+
+struct Type
+{
+public:
+    Span<const char> imageUrl;
+    Span<const char> color;
+    uint8_t size;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace ContentLaunchStyleInformation
+} // namespace Structs
+
+namespace Commands {
+namespace LaunchContent {
+enum class Fields
+{
+    kAutoPlay = 0,
+    kData     = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return LaunchContent::Id; }
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+
+    bool autoPlay;
+    Span<const char> data;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return LaunchContent::Id; }
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+
+    bool autoPlay;
+    Span<const char> data;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchContent
+namespace LaunchContentResponse {
+enum class Fields
+{
+    kData                = 0,
+    kContentLaunchStatus = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return LaunchContentResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+
+    Span<const char> data;
+    ContentLaunchStatus contentLaunchStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return LaunchContentResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+
+    Span<const char> data;
+    ContentLaunchStatus contentLaunchStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchContentResponse
+namespace LaunchURL {
+enum class Fields
+{
+    kContentURL    = 0,
+    kDisplayString = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return LaunchURL::Id; }
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+
+    Span<const char> contentURL;
+    Span<const char> displayString;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return LaunchURL::Id; }
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+
+    Span<const char> contentURL;
+    Span<const char> displayString;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchURL
+namespace LaunchURLResponse {
+enum class Fields
+{
+    kData                = 0,
+    kContentLaunchStatus = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return LaunchURLResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+
+    Span<const char> data;
+    ContentLaunchStatus contentLaunchStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return LaunchURLResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+
+    Span<const char> data;
+    ContentLaunchStatus contentLaunchStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchURLResponse
+} // namespace Commands
+
+namespace Attributes {
+namespace AcceptsHeaderList {
+struct TypeInfo
+{
+    using Type = DataModel::List<chip::ByteSpan>;
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcceptsHeaderList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<chip::ByteSpan>;
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcceptsHeaderList::Id; }
+};
+} // namespace AcceptsHeaderList
+namespace SupportedStreamingTypes {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SupportedStreamingTypes::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SupportedStreamingTypes::Id; }
+};
+} // namespace SupportedStreamingTypes
+} // namespace Attributes
+} // namespace ContentLauncher
+namespace AudioOutput {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for AudioOutputType
+enum class AudioOutputType : uint8_t
+{
+    AUDIO_OUTPUT_TYPE_HDMI      = 0x00,
+    AUDIO_OUTPUT_TYPE_BT        = 0x01,
+    AUDIO_OUTPUT_TYPE_OPTICAL   = 0x02,
+    AUDIO_OUTPUT_TYPE_HEADPHONE = 0x03,
+    AUDIO_OUTPUT_TYPE_INTERNAL  = 0x04,
+    AUDIO_OUTPUT_TYPE_OTHER     = 0x05,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using AudioOutputType                      = EmberAfAudioOutputType;
+#endif
+
+namespace Structs {
+namespace AudioOutputInfo {
+enum class Fields
+{
+    kIndex      = 0,
+    kOutputType = 1,
+    kName       = 2,
+};
+
+struct Type
+{
+public:
+    uint8_t index;
+    AudioOutputType outputType;
+    chip::ByteSpan name;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace AudioOutputInfo
+} // namespace Structs
+
+namespace Commands {
+namespace SelectOutput {
+enum class Fields
+{
+    kIndex = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SelectOutput::Id; }
+    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+
+    uint8_t index;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SelectOutput::Id; }
+    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+
+    uint8_t index;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SelectOutput
+namespace RenameOutput {
+enum class Fields
+{
+    kIndex = 0,
+    kName  = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RenameOutput::Id; }
+    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+
+    uint8_t index;
+    Span<const char> name;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return RenameOutput::Id; }
+    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+
+    uint8_t index;
+    Span<const char> name;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RenameOutput
+} // namespace Commands
+
+namespace Attributes {
+namespace AudioOutputList {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::AudioOutputInfo::Type>;
+    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AudioOutputList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::AudioOutputInfo::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AudioOutputList::Id; }
+};
+} // namespace AudioOutputList
+namespace CurrentAudioOutput {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentAudioOutput::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentAudioOutput
+} // namespace Attributes
+} // namespace AudioOutput
+namespace ApplicationLauncher {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for ApplicationLauncherStatus
+enum class ApplicationLauncherStatus : uint8_t
+{
+    APPLICATION_LAUNCHER_STATUS_SUCCESS           = 0x00,
+    APPLICATION_LAUNCHER_STATUS_APP_NOT_AVAILABLE = 0x01,
+    APPLICATION_LAUNCHER_STATUS_SYSTEM_BUSY       = 0x02,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using ApplicationLauncherStatus            = EmberAfApplicationLauncherStatus;
+#endif
+
+namespace Structs {
+namespace ApplicationLauncherApp {
+enum class Fields
+{
+    kCatalogVendorId = 0,
+    kApplicationId   = 1,
+};
+
+struct Type
+{
+public:
+    uint16_t catalogVendorId;
+    Span<const char> applicationId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace ApplicationLauncherApp
+} // namespace Structs
+
+namespace Commands {
+namespace LaunchApp {
+enum class Fields
+{
+    kData            = 0,
+    kCatalogVendorId = 1,
+    kApplicationId   = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return LaunchApp::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+
+    Span<const char> data;
+    uint16_t catalogVendorId;
+    Span<const char> applicationId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return LaunchApp::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+
+    Span<const char> data;
+    uint16_t catalogVendorId;
+    Span<const char> applicationId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchApp
+namespace LaunchAppResponse {
+enum class Fields
+{
+    kStatus = 0,
+    kData   = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return LaunchAppResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+
+    ApplicationLauncherStatus status;
+    Span<const char> data;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return LaunchAppResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+
+    ApplicationLauncherStatus status;
+    Span<const char> data;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchAppResponse
+} // namespace Commands
+
+namespace Attributes {
+namespace ApplicationLauncherList {
+struct TypeInfo
+{
+    using Type = DataModel::List<uint16_t>;
+    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationLauncherList::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint16_t>;
+    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationLauncherList::Id; }
+};
+} // namespace ApplicationLauncherList
+namespace CatalogVendorId {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CatalogVendorId::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CatalogVendorId
+namespace ApplicationId {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationId::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ApplicationId
+} // namespace Attributes
+} // namespace ApplicationLauncher
+namespace ApplicationBasic {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for ApplicationBasicStatus
+enum class ApplicationBasicStatus : uint8_t
+{
+    APPLICATION_BASIC_STATUS_STOPPED                  = 0x00,
+    APPLICATION_BASIC_STATUS_ACTIVE_VISIBLE_FOCUS     = 0x01,
+    APPLICATION_BASIC_STATUS_ACTIVE_HIDDEN            = 0x02,
+    APPLICATION_BASIC_STATUS_ACTIVE_VISIBLE_NOT_FOCUS = 0x03,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using ApplicationBasicStatus               = EmberAfApplicationBasicStatus;
+#endif
+
+namespace Commands {
+namespace ChangeStatus {
+enum class Fields
+{
+    kStatus = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ChangeStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+
+    ApplicationBasicStatus status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ChangeStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+
+    ApplicationBasicStatus status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeStatus
+} // namespace Commands
+
+namespace Attributes {
+namespace VendorName {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::VendorName::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace VendorName
+namespace VendorId {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::VendorId::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace VendorId
+namespace ApplicationName {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationName::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ApplicationName
+namespace ProductId {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductId::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductId
+namespace ApplicationId {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationId::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ApplicationId
+namespace CatalogVendorId {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CatalogVendorId::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace CatalogVendorId
+namespace ApplicationStatus {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationStatus::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ApplicationStatus
+} // namespace Attributes
+} // namespace ApplicationBasic
+namespace AccountLogin {
+
+namespace Commands {
+namespace GetSetupPIN {
+enum class Fields
+{
+    kTempAccountIdentifier = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetSetupPIN::Id; }
+    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+
+    Span<const char> tempAccountIdentifier;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetSetupPIN::Id; }
+    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+
+    Span<const char> tempAccountIdentifier;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetSetupPIN
+namespace GetSetupPINResponse {
+enum class Fields
+{
+    kSetupPIN = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetSetupPINResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+
+    Span<const char> setupPIN;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetSetupPINResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+
+    Span<const char> setupPIN;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetSetupPINResponse
+namespace Login {
+enum class Fields
+{
+    kTempAccountIdentifier = 0,
+    kSetupPIN              = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Login::Id; }
+    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+
+    Span<const char> tempAccountIdentifier;
+    Span<const char> setupPIN;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Login::Id; }
+    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+
+    Span<const char> tempAccountIdentifier;
+    Span<const char> setupPIN;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Login
+} // namespace Commands
+
+} // namespace AccountLogin
+namespace TestCluster {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for SimpleEnum
+enum class SimpleEnum : uint8_t
+{
+    SIMPLE_ENUM_UNSPECIFIED = 0x00,
+    SIMPLE_ENUM_VALUE_A     = 0x01,
+    SIMPLE_ENUM_VALUE_B     = 0x02,
+    SIMPLE_ENUM_VALUE_C     = 0x03,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using SimpleEnum                           = EmberAfSimpleEnum;
+#endif
+
+namespace Structs {
+namespace SimpleStruct {
+enum class Fields
+{
+    kA = 0,
+    kB = 1,
+    kC = 2,
+    kD = 3,
+    kE = 4,
+};
+
+struct Type
+{
+public:
+    uint8_t a;
+    bool b;
+    SimpleEnum c;
+    chip::ByteSpan d;
+    Span<const char> e;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace SimpleStruct
+namespace NestedStruct {
+enum class Fields
+{
+    kA = 0,
+    kB = 1,
+    kC = 2,
+};
+
+struct Type
+{
+public:
+    uint8_t a;
+    bool b;
+    Structs::SimpleStruct::Type c;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace NestedStruct
+namespace NestedStructList {
+enum class Fields
+{
+    kA = 0,
+    kB = 1,
+    kC = 2,
+    kD = 3,
+    kE = 4,
+    kF = 5,
+    kG = 6,
+};
+
+struct Type
+{
+public:
+    uint8_t a;
+    bool b;
+    Structs::SimpleStruct::Type c;
+    DataModel::List<Structs::SimpleStruct::Type> d;
+    DataModel::List<uint32_t> e;
+    DataModel::List<chip::ByteSpan> f;
+    DataModel::List<uint8_t> g;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    uint8_t a;
+    bool b;
+    Structs::SimpleStruct::DecodableType c;
+    DataModel::DecodableList<Structs::SimpleStruct::DecodableType> d;
+    DataModel::DecodableList<uint32_t> e;
+    DataModel::DecodableList<chip::ByteSpan> f;
+    DataModel::DecodableList<uint8_t> g;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+} // namespace NestedStructList
+namespace DoubleNestedStructList {
+enum class Fields
+{
+    kA = 0,
+};
+
+struct Type
+{
+public:
+    DataModel::List<Structs::NestedStructList::Type> a;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    DataModel::DecodableList<Structs::NestedStructList::DecodableType> a;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+} // namespace DoubleNestedStructList
+namespace TestListStructOctet {
+enum class Fields
+{
+    kFabricIndex     = 0,
+    kOperationalCert = 1,
+};
+
+struct Type
+{
+public:
+    uint64_t fabricIndex;
+    chip::ByteSpan operationalCert;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+
+using DecodableType = Type;
+
+} // namespace TestListStructOctet
+} // namespace Structs
+
+namespace Commands {
+namespace Test {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Test::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return Test::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Test
+namespace TestSpecificResponse {
+enum class Fields
+{
+    kReturnValue = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TestSpecificResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    uint8_t returnValue;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestSpecificResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    uint8_t returnValue;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSpecificResponse
+namespace TestNotHandled {
+enum class Fields
+{
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TestNotHandled::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestNotHandled::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestNotHandled
+namespace TestAddArgumentsResponse {
+enum class Fields
+{
+    kReturnValue = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TestAddArgumentsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    uint8_t returnValue;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestAddArgumentsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    uint8_t returnValue;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestAddArgumentsResponse
+namespace TestSpecific {
+enum class Fields
 {
-    KEYPAD_INPUT_CEC_KEY_CODE_SELECT                       = 0x00,
-    KEYPAD_INPUT_CEC_KEY_CODE_UP                           = 0x01,
-    KEYPAD_INPUT_CEC_KEY_CODE_DOWN                         = 0x02,
-    KEYPAD_INPUT_CEC_KEY_CODE_LEFT                         = 0x03,
-    KEYPAD_INPUT_CEC_KEY_CODE_RIGHT                        = 0x04,
-    KEYPAD_INPUT_CEC_KEY_CODE_RIGHT_UP                     = 0x05,
-    KEYPAD_INPUT_CEC_KEY_CODE_RIGHT_DOWN                   = 0x06,
-    KEYPAD_INPUT_CEC_KEY_CODE_LEFT_UP                      = 0x07,
-    KEYPAD_INPUT_CEC_KEY_CODE_LEFT_DOWN                    = 0x08,
-    KEYPAD_INPUT_CEC_KEY_CODE_ROOT_MENU                    = 0x09,
-    KEYPAD_INPUT_CEC_KEY_CODE_SETUP_MENU                   = 0x0A,
-    KEYPAD_INPUT_CEC_KEY_CODE_CONTENTS_MENU                = 0x0B,
-    KEYPAD_INPUT_CEC_KEY_CODE_FAVORITE_MENU                = 0x0C,
-    KEYPAD_INPUT_CEC_KEY_CODE_EXIT                         = 0x0D,
-    KEYPAD_INPUT_CEC_KEY_CODE_MEDIA_TOP_MENU               = 0x10,
-    KEYPAD_INPUT_CEC_KEY_CODE_MEDIA_CONTEXT_SENSITIVE_MENU = 0x11,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBER_ENTRY_MODE            = 0x1D,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBER11                     = 0x1E,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBER12                     = 0x1F,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBER0_OR_NUMBER10          = 0x20,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS1                     = 0x21,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS2                     = 0x22,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS3                     = 0x23,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS4                     = 0x24,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS5                     = 0x25,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS6                     = 0x26,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS7                     = 0x27,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS8                     = 0x28,
-    KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS9                     = 0x29,
-    KEYPAD_INPUT_CEC_KEY_CODE_DOT                          = 0x2A,
-    KEYPAD_INPUT_CEC_KEY_CODE_ENTER                        = 0x2B,
-    KEYPAD_INPUT_CEC_KEY_CODE_CLEAR                        = 0x2C,
-    KEYPAD_INPUT_CEC_KEY_CODE_NEXT_FAVORITE                = 0x2F,
-    KEYPAD_INPUT_CEC_KEY_CODE_CHANNEL_UP                   = 0x30,
-    KEYPAD_INPUT_CEC_KEY_CODE_CHANNEL_DOWN                 = 0x31,
-    KEYPAD_INPUT_CEC_KEY_CODE_PREVIOUS_CHANNEL             = 0x32,
-    KEYPAD_INPUT_CEC_KEY_CODE_SOUND_SELECT                 = 0x33,
-    KEYPAD_INPUT_CEC_KEY_CODE_INPUT_SELECT                 = 0x34,
-    KEYPAD_INPUT_CEC_KEY_CODE_DISPLAY_INFORMATION          = 0x35,
-    KEYPAD_INPUT_CEC_KEY_CODE_HELP                         = 0x36,
-    KEYPAD_INPUT_CEC_KEY_CODE_PAGE_UP                      = 0x37,
-    KEYPAD_INPUT_CEC_KEY_CODE_PAGE_DOWN                    = 0x38,
-    KEYPAD_INPUT_CEC_KEY_CODE_POWER                        = 0x40,
-    KEYPAD_INPUT_CEC_KEY_CODE_VOLUME_UP                    = 0x41,
-    KEYPAD_INPUT_CEC_KEY_CODE_VOLUME_DOWN                  = 0x42,
-    KEYPAD_INPUT_CEC_KEY_CODE_MUTE                         = 0x43,
-    KEYPAD_INPUT_CEC_KEY_CODE_PLAY                         = 0x44,
-    KEYPAD_INPUT_CEC_KEY_CODE_STOP                         = 0x45,
-    KEYPAD_INPUT_CEC_KEY_CODE_PAUSE                        = 0x46,
-    KEYPAD_INPUT_CEC_KEY_CODE_RECORD                       = 0x47,
-    KEYPAD_INPUT_CEC_KEY_CODE_REWIND                       = 0x48,
-    KEYPAD_INPUT_CEC_KEY_CODE_FAST_FORWARD                 = 0x49,
-    KEYPAD_INPUT_CEC_KEY_CODE_EJECT                        = 0x4A,
-    KEYPAD_INPUT_CEC_KEY_CODE_FORWARD                      = 0x4B,
-    KEYPAD_INPUT_CEC_KEY_CODE_BACKWARD                     = 0x4C,
-    KEYPAD_INPUT_CEC_KEY_CODE_STOP_RECORD                  = 0x4D,
-    KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_RECORD                 = 0x4E,
-    KEYPAD_INPUT_CEC_KEY_CODE_RESERVED                     = 0x4F,
-    KEYPAD_INPUT_CEC_KEY_CODE_ANGLE                        = 0x50,
-    KEYPAD_INPUT_CEC_KEY_CODE_SUB_PICTURE                  = 0x51,
-    KEYPAD_INPUT_CEC_KEY_CODE_VIDEO_ON_DEMAND              = 0x52,
-    KEYPAD_INPUT_CEC_KEY_CODE_ELECTRONIC_PROGRAM_GUIDE     = 0x53,
-    KEYPAD_INPUT_CEC_KEY_CODE_TIMER_PROGRAMMING            = 0x54,
-    KEYPAD_INPUT_CEC_KEY_CODE_INITIAL_CONFIGURATION        = 0x55,
-    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_BROADCAST_TYPE        = 0x56,
-    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_SOUND_PRESENTATION    = 0x57,
-    KEYPAD_INPUT_CEC_KEY_CODE_PLAY_FUNCTION                = 0x60,
-    KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_PLAY_FUNCTION          = 0x61,
-    KEYPAD_INPUT_CEC_KEY_CODE_RECORD_FUNCTION              = 0x62,
-    KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_RECORD_FUNCTION        = 0x63,
-    KEYPAD_INPUT_CEC_KEY_CODE_STOP_FUNCTION                = 0x64,
-    KEYPAD_INPUT_CEC_KEY_CODE_MUTE_FUNCTION                = 0x65,
-    KEYPAD_INPUT_CEC_KEY_CODE_RESTORE_VOLUME_FUNCTION      = 0x66,
-    KEYPAD_INPUT_CEC_KEY_CODE_TUNE_FUNCTION                = 0x67,
-    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_MEDIA_FUNCTION        = 0x68,
-    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_AV_INPUT_FUNCTION     = 0x69,
-    KEYPAD_INPUT_CEC_KEY_CODE_SELECT_AUDIO_INPUT_FUNCTION  = 0x6A,
-    KEYPAD_INPUT_CEC_KEY_CODE_POWER_TOGGLE_FUNCTION        = 0x6B,
-    KEYPAD_INPUT_CEC_KEY_CODE_POWER_OFF_FUNCTION           = 0x6C,
-    KEYPAD_INPUT_CEC_KEY_CODE_POWER_ON_FUNCTION            = 0x6D,
-    KEYPAD_INPUT_CEC_KEY_CODE_F1_BLUE                      = 0x71,
-    KEYPAD_INPUT_CEC_KEY_CODE_F2_RED                       = 0x72,
-    KEYPAD_INPUT_CEC_KEY_CODE_F3_GREEN                     = 0x73,
-    KEYPAD_INPUT_CEC_KEY_CODE_F4_YELLOW                    = 0x74,
-    KEYPAD_INPUT_CEC_KEY_CODE_F5                           = 0x75,
-    KEYPAD_INPUT_CEC_KEY_CODE_DATA                         = 0x76,
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using KeypadInputCecKeyCode                = EmberAfKeypadInputCecKeyCode;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for KeypadInputStatus
-enum class KeypadInputStatus : uint8_t
+
+struct Type
 {
-    KEYPAD_INPUT_STATUS_SUCCESS                      = 0x00,
-    KEYPAD_INPUT_STATUS_UNSUPPORTED_KEY              = 0x01,
-    KEYPAD_INPUT_STATUS_INVALID_KEY_IN_CURRENT_STATE = 0x02,
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TestSpecific::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using KeypadInputStatus                    = EmberAfKeypadInputStatus;
-#endif
 
-namespace Commands {
-namespace SendKey {
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestSpecific::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSpecific
+namespace TestSimpleArgumentResponse {
 enum class Fields
 {
-    kKeyCode = 0,
+    kReturnValue = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SendKey::Id; }
-    static constexpr ClusterId GetClusterId() { return KeypadInput::Id; }
+    static constexpr CommandId GetCommandId() { return TestSimpleArgumentResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
 
-    KeypadInputCecKeyCode keyCode;
+    bool returnValue;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -11522,27 +20284,61 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SendKey::Id; }
-    static constexpr ClusterId GetClusterId() { return KeypadInput::Id; }
+    static constexpr CommandId GetCommandId() { return TestSimpleArgumentResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
 
-    KeypadInputCecKeyCode keyCode;
+    bool returnValue;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SendKey
-namespace SendKeyResponse {
+}; // namespace TestSimpleArgumentResponse
+namespace TestUnknownCommand {
 enum class Fields
 {
-    kStatus = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SendKeyResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return KeypadInput::Id; }
+    static constexpr CommandId GetCommandId() { return TestUnknownCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
 
-    KeypadInputStatus status;
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestUnknownCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestUnknownCommand
+namespace TestStructArrayArgumentResponse {
+enum class Fields
+{
+    kArg1 = 0,
+    kArg2 = 1,
+    kArg3 = 2,
+    kArg4 = 3,
+    kArg5 = 4,
+    kArg6 = 5,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    DataModel::List<Structs::NestedStructList::Type> arg1;
+    DataModel::List<Structs::SimpleStruct::Type> arg2;
+    DataModel::List<SimpleEnum> arg3;
+    DataModel::List<bool> arg4;
+    SimpleEnum arg5;
+    bool arg6;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -11550,277 +20346,560 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SendKeyResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return KeypadInput::Id; }
+    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
 
-    KeypadInputStatus status;
+    DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
+    DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg2;
+    DataModel::DecodableList<SimpleEnum> arg3;
+    DataModel::DecodableList<bool> arg4;
+    SimpleEnum arg5;
+    bool arg6;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SendKeyResponse
-} // namespace Commands
-} // namespace KeypadInput
-namespace ContentLauncher {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ContentLaunchMetricType
-enum class ContentLaunchMetricType : uint8_t
+}; // namespace TestStructArrayArgumentResponse
+namespace TestAddArguments {
+enum class Fields
 {
-    CONTENT_LAUNCH_METRIC_TYPE_PIXELS     = 0x00,
-    CONTENT_LAUNCH_METRIC_TYPE_PERCENTAGE = 0x01,
+    kArg1 = 0,
+    kArg2 = 1,
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ContentLaunchMetricType              = EmberAfContentLaunchMetricType;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ContentLaunchParameterEnum
-enum class ContentLaunchParameterEnum : uint8_t
+
+struct Type
 {
-    CONTENT_LAUNCH_PARAMETER_ENUM_ACTOR       = 0x00,
-    CONTENT_LAUNCH_PARAMETER_ENUM_CHANNEL     = 0x01,
-    CONTENT_LAUNCH_PARAMETER_ENUM_CHARACTER   = 0x02,
-    CONTENT_LAUNCH_PARAMETER_ENUM_EVENT       = 0x03,
-    CONTENT_LAUNCH_PARAMETER_ENUM_FRANCHISE   = 0x04,
-    CONTENT_LAUNCH_PARAMETER_ENUM_GENRE       = 0x05,
-    CONTENT_LAUNCH_PARAMETER_ENUM_LEAGUE      = 0x06,
-    CONTENT_LAUNCH_PARAMETER_ENUM_POPULARITY  = 0x07,
-    CONTENT_LAUNCH_PARAMETER_ENUM_SPORT       = 0x08,
-    CONTENT_LAUNCH_PARAMETER_ENUM_SPORTS_TEAM = 0x09,
-    CONTENT_LAUNCH_PARAMETER_ENUM_VIDEO       = 0x0A,
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TestAddArguments::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    uint8_t arg1;
+    uint8_t arg2;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ContentLaunchParameterEnum           = EmberAfContentLaunchParameterEnum;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ContentLaunchStatus
-enum class ContentLaunchStatus : uint8_t
+
+struct DecodableType
 {
-    CONTENT_LAUNCH_STATUS_SUCCESS           = 0x00,
-    CONTENT_LAUNCH_STATUS_URL_NOT_AVAILABLE = 0x01,
-    CONTENT_LAUNCH_STATUS_AUTH_FAILED       = 0x02,
+public:
+    static constexpr CommandId GetCommandId() { return TestAddArguments::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    uint8_t arg1;
+    uint8_t arg2;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ContentLaunchStatus                  = EmberAfContentLaunchStatus;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ContentLaunchStreamingType
-enum class ContentLaunchStreamingType : uint8_t
+}; // namespace TestAddArguments
+namespace TestSimpleArgumentRequest {
+enum class Fields
+{
+    kArg1 = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TestSimpleArgumentRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    bool arg1;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestSimpleArgumentRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    bool arg1;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSimpleArgumentRequest
+namespace TestStructArrayArgumentRequest {
+enum class Fields
+{
+    kArg1 = 0,
+    kArg2 = 1,
+    kArg3 = 2,
+    kArg4 = 3,
+    kArg5 = 4,
+    kArg6 = 5,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    DataModel::List<Structs::NestedStructList::Type> arg1;
+    DataModel::List<Structs::SimpleStruct::Type> arg2;
+    DataModel::List<SimpleEnum> arg3;
+    DataModel::List<bool> arg4;
+    SimpleEnum arg5;
+    bool arg6;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
+    DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg2;
+    DataModel::DecodableList<SimpleEnum> arg3;
+    DataModel::DecodableList<bool> arg4;
+    SimpleEnum arg5;
+    bool arg6;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestStructArrayArgumentRequest
+} // namespace Commands
+
+namespace Attributes {
+namespace Boolean {
+struct TypeInfo
 {
-    CONTENT_LAUNCH_STREAMING_TYPE_DASH = 0x00,
-    CONTENT_LAUNCH_STREAMING_TYPE_HLS  = 0x01,
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Boolean::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ContentLaunchStreamingType           = EmberAfContentLaunchStreamingType;
-#endif
 
-namespace Structs {
-namespace ContentLaunchAdditionalInfo {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace Boolean
+namespace Bitmap8 {
+struct TypeInfo
 {
-    kName  = 0,
-    kValue = 1,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Bitmap8::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Bitmap8
+namespace Bitmap16 {
+struct TypeInfo
 {
-public:
-    Span<const char> name;
-    Span<const char> value;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Bitmap16::Id; }
 };
 
-using DecodableType = Type;
-
-} // namespace ContentLaunchAdditionalInfo
-namespace ContentLaunchParamater {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace Bitmap16
+namespace Bitmap32 {
+struct TypeInfo
 {
-    kType           = 0,
-    kValue          = 1,
-    kExternalIDList = 2,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Bitmap32::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Bitmap32
+namespace Bitmap64 {
+struct TypeInfo
 {
-public:
-    ContentLaunchParameterEnum type;
-    Span<const char> value;
-    DataModel::List<Structs::ContentLaunchAdditionalInfo::Type> externalIDList;
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Bitmap64::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Bitmap64
+namespace Int8u {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Int8u::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace Int8u
+namespace Int16u {
+struct TypeInfo
 {
-public:
-    ContentLaunchParameterEnum type;
-    Span<const char> value;
-    DataModel::DecodableList<Structs::ContentLaunchAdditionalInfo::DecodableType> externalIDList;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Int16u::Id; }
 };
 
-} // namespace ContentLaunchParamater
-namespace ContentLaunchBrandingInformation {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace Int16u
+namespace Int32u {
+struct TypeInfo
 {
-    kProviderName = 0,
-    kBackground   = 1,
-    kLogo         = 2,
-    kProgressBar  = 3,
-    kSplash       = 4,
-    kWaterMark    = 5,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Int32u::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Int32u
+namespace Int64u {
+struct TypeInfo
 {
-public:
-    Span<const char> providerName;
-    uint8_t background;
-    uint8_t logo;
-    uint8_t progressBar;
-    uint8_t splash;
-    uint8_t waterMark;
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Int64u::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Int64u
+namespace Int8s {
+struct TypeInfo
+{
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Int8s::Id; }
 };
 
-using DecodableType = Type;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Int8s
+namespace Int16s {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Int16s::Id; }
+};
 
-} // namespace ContentLaunchBrandingInformation
-namespace ContentLaunchDimension {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace Int16s
+namespace Int32s {
+struct TypeInfo
 {
-    kWidth  = 0,
-    kHeight = 1,
-    kMetric = 2,
+    using Type = int32_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Int32s::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Int32s
+namespace Int64s {
+struct TypeInfo
 {
-public:
-    Span<const char> width;
-    Span<const char> height;
-    ContentLaunchMetricType metric;
+    using Type = int64_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Int64s::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Int64s
+namespace Enum8 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Enum8::Id; }
 };
 
-using DecodableType = Type;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Enum8
+namespace Enum16 {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Enum16::Id; }
+};
 
-} // namespace ContentLaunchDimension
-namespace ContentLaunchStyleInformation {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace Enum16
+namespace OctetString {
+struct TypeInfo
 {
-    kImageUrl = 0,
-    kColor    = 1,
-    kSize     = 2,
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OctetString::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace OctetString
+namespace ListInt8u {
+struct TypeInfo
 {
-public:
-    Span<const char> imageUrl;
-    Span<const char> color;
-    uint8_t size;
+    using Type = DataModel::List<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ListInt8u::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<uint8_t>;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ListInt8u::Id; }
+};
+} // namespace ListInt8u
+namespace ListOctetString {
+struct TypeInfo
+{
+    using Type = DataModel::List<chip::ByteSpan>;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ListOctetString::Id; }
 };
 
-using DecodableType = Type;
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<chip::ByteSpan>;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ListOctetString::Id; }
+};
+} // namespace ListOctetString
+namespace ListStructOctetString {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::TestListStructOctet::Type>;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ListStructOctetString::Id; }
+};
 
-} // namespace ContentLaunchStyleInformation
-} // namespace Structs
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::TestListStructOctet::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ListStructOctetString::Id; }
+};
+} // namespace ListStructOctetString
+namespace LongOctetString {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LongOctetString::Id; }
+};
 
-namespace Commands {
-namespace LaunchContent {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace LongOctetString
+namespace CharString {
+struct TypeInfo
 {
-    kAutoPlay = 0,
-    kData     = 1,
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CharString::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace CharString
+namespace LongCharString {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LaunchContent::Id; }
-    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LongCharString::Id; }
+};
 
-    bool autoPlay;
-    Span<const char> data;
+using DecodableTypeInfo = TypeInfo;
+} // namespace LongCharString
+namespace EpochUs {
+struct TypeInfo
+{
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EpochUs::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace EpochUs
+namespace EpochS {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EpochS::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace EpochS
+namespace Unsupported {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return LaunchContent::Id; }
-    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+    using Type = bool;
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Unsupported::Id; }
+};
 
-    bool autoPlay;
-    Span<const char> data;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Unsupported
+} // namespace Attributes
+} // namespace TestCluster
+namespace Messaging {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for EventId
+enum class EventId : uint8_t
+{
+    EVENT_ID_METER_COVER_REMOVED                   = 0x00,
+    EVENT_ID_METER_COVER_CLOSED                    = 0x01,
+    EVENT_ID_STRONG_MAGNETIC_FIELD                 = 0x02,
+    EVENT_ID_NO_STRONG_MAGNETIC_FIELD              = 0x03,
+    EVENT_ID_BATTERY_FAILURE                       = 0x04,
+    EVENT_ID_LOW_BATTERY                           = 0x05,
+    EVENT_ID_PROGRAM_MEMORY_ERROR                  = 0x06,
+    EVENT_ID_RAM_ERROR                             = 0x07,
+    EVENT_ID_NV_MEMORY_ERROR                       = 0x08,
+    EVENT_ID_MEASUREMENT_SYSTEM_ERROR              = 0x09,
+    EVENT_ID_WATCHDOG_ERROR                        = 0x0A,
+    EVENT_ID_SUPPLY_DISCONNECT_FAILURE             = 0x0B,
+    EVENT_ID_SUPPLY_CONNECT_FAILURE                = 0x0C,
+    EVENT_ID_MEASURMENT_SOFTWARE_CHANGED           = 0x0D,
+    EVENT_ID_DST_ENABLED                           = 0x0E,
+    EVENT_ID_DST_DISABLED                          = 0x0F,
+    EVENT_ID_CLOCK_ADJ_BACKWARD                    = 0x10,
+    EVENT_ID_CLOCK_ADJ_FORWARD                     = 0x11,
+    EVENT_ID_CLOCK_INVALID                         = 0x12,
+    EVENT_ID_COMMS_ERROR_HAN                       = 0x13,
+    EVENT_ID_COMMS_OK_HAN                          = 0x14,
+    EVENT_ID_FRAUD_ATTEMPT                         = 0x15,
+    EVENT_ID_POWER_LOSS                            = 0x16,
+    EVENT_ID_INCORRECT_PROTOCOL                    = 0x17,
+    EVENT_ID_UNUSUAL_HAN_TRAFFIC                   = 0x18,
+    EVENT_ID_UNEXPECTED_CLOCK_CHANGE               = 0x19,
+    EVENT_ID_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x1A,
+    EVENT_ID_ERROR_REG_CLEAR                       = 0x1B,
+    EVENT_ID_ALARM_REG_CLEAR                       = 0x1C,
+    EVENT_ID_UNEXPECTED_HW_RESET                   = 0x1D,
+    EVENT_ID_UNEXPECTED_PROGRAM_EXECUTION          = 0x1E,
+    EVENT_ID_EVENT_LOG_CLEARED                     = 0x1F,
+    EVENT_ID_MANUAL_DISCONNECT                     = 0x20,
+    EVENT_ID_MANUAL_CONNECT                        = 0x21,
+    EVENT_ID_REMOTE_DISCONNECTION                  = 0x22,
+    EVENT_ID_LOCAL_DISCONNECTION                   = 0x23,
+    EVENT_ID_LIMIT_THRESHOLD_EXCEEDED              = 0x24,
+    EVENT_ID_LIMIT_THRESHOLD_OK                    = 0x25,
+    EVENT_ID_LIMIT_THRESHOLD_CHANGED               = 0x26,
+    EVENT_ID_MAXIMUM_DEMAND_EXCEEDED               = 0x27,
+    EVENT_ID_PROFILE_CLEARED                       = 0x28,
+    EVENT_ID_FIRMWARE_READY_FOR_ACTIVATION         = 0x29,
+    EVENT_ID_FIRMWARE_ACTIVATED                    = 0x2A,
+    EVENT_ID_PATCH_FAILURE                         = 0x2B,
+    EVENT_ID_TOU_TARIFF_ACTIVATION                 = 0x2C,
+    EVENT_ID_8X8_TARIFFACTIVATED                   = 0x2D,
+    EVENT_ID_SINGLE_TARIFF_RATE_ACTIVATED          = 0x2E,
+    EVENT_ID_ASYNCHRONOUS_BILLING_OCCURRED         = 0x2F,
+    EVENT_ID_SYNCHRONOUS_BILLING_OCCURRED          = 0x30,
+    EVENT_ID_INCORRECT_POLARITY                    = 0x80,
+    EVENT_ID_CURRENT_NO_VOLTAGE                    = 0x81,
+    EVENT_ID_UNDER_VOLTAGE                         = 0x82,
+    EVENT_ID_OVER_VOLTAGE                          = 0x83,
+    EVENT_ID_NORMAL_VOLTAGE                        = 0x84,
+    EVENT_ID_PF_BELOW_THRESHOLD                    = 0x85,
+    EVENT_ID_PF_ABOVE_THRESHOLD                    = 0x86,
+    EVENT_ID_TERMINAL_COVER_REMOVED                = 0x87,
+    EVENT_ID_TERMINAL_COVER_CLOSED                 = 0x88,
+    EVENT_ID_REVERSE_FLOW                          = 0xA0,
+    EVENT_ID_TILT_TAMPER                           = 0xA1,
+    EVENT_ID_BATTERY_COVER_REMOVED                 = 0xA2,
+    EVENT_ID_BATTERY_COVER_CLOSED                  = 0xA3,
+    EVENT_ID_EXCESS_FLOW                           = 0xA4,
+    EVENT_ID_CREDIT_OK                             = 0xC0,
+    EVENT_ID_LOW_CREDIT                            = 0xC1,
+    EVENT_ID_EMERGENCY_CREDIT_IN_USE               = 0xC0,
+    EVENT_ID_EMERGENCY_CREDIT_EXHAUSTED            = 0xC1,
+    EVENT_ID_ZERO_CREDIT_EC_NOT_SELECTED           = 0xC2,
+    EVENT_ID_SUPPLY_ON                             = 0xC3,
+    EVENT_ID_SUPPLY_OFF_AARMED                     = 0xC4,
+    EVENT_ID_SUPPLY_OFF                            = 0xC5,
+    EVENT_ID_DISCOUNT_APPLIED                      = 0xC6,
+    EVENT_ID_MANUFACTURER_SPECIFIC_A               = 0xE0,
+    EVENT_ID_MANUFACTURER_SPECIFIC_B               = 0xE1,
+    EVENT_ID_MANUFACTURER_SPECIFIC_C               = 0xE2,
+    EVENT_ID_MANUFACTURER_SPECIFIC_D               = 0xE3,
+    EVENT_ID_MANUFACTURER_SPECIFIC_E               = 0xE4,
+    EVENT_ID_MANUFACTURER_SPECIFIC_F               = 0xE5,
+    EVENT_ID_MANUFACTURER_SPECIFIC_G               = 0xE6,
+    EVENT_ID_MANUFACTURER_SPECIFIC_H               = 0xE7,
+    EVENT_ID_MANUFACTURER_SPECIFIC_I               = 0xE8,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using EventId                              = EmberAfEventId;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for MessagingControlConfirmation
+enum class MessagingControlConfirmation : uint8_t
+{
+    MESSAGING_CONTROL_CONFIRMATION_NOT_REQUIRED = 0x00,
+    MESSAGING_CONTROL_CONFIRMATION_REQUIRED     = 0x80,
 };
-}; // namespace LaunchContent
-namespace LaunchContentResponse {
-enum class Fields
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using MessagingControlConfirmation         = EmberAfMessagingControlConfirmation;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for MessagingControlEnhancedConfirmation
+enum class MessagingControlEnhancedConfirmation : uint8_t
 {
-    kData                = 0,
-    kContentLaunchStatus = 1,
+    MESSAGING_CONTROL_ENHANCED_CONFIRMATION_NOT_REQUIRED = 0x00,
+    MESSAGING_CONTROL_ENHANCED_CONFIRMATION_REQUIRED     = 0x20,
 };
-
-struct Type
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using MessagingControlEnhancedConfirmation = EmberAfMessagingControlEnhancedConfirmation;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for MessagingControlImportance
+enum class MessagingControlImportance : uint8_t
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LaunchContentResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
-
-    Span<const char> data;
-    ContentLaunchStatus contentLaunchStatus;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    MESSAGING_CONTROL_IMPORTANCE_LOW      = 0x00,
+    MESSAGING_CONTROL_IMPORTANCE_MEDIUM   = 0x04,
+    MESSAGING_CONTROL_IMPORTANCE_HIGH     = 0x08,
+    MESSAGING_CONTROL_IMPORTANCE_CRITICAL = 0x0C,
 };
-
-struct DecodableType
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using MessagingControlImportance           = EmberAfMessagingControlImportance;
+#endif
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for MessagingControlTransmission
+enum class MessagingControlTransmission : uint8_t
 {
-public:
-    static constexpr CommandId GetCommandId() { return LaunchContentResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
-
-    Span<const char> data;
-    ContentLaunchStatus contentLaunchStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+    MESSAGING_CONTROL_TRANSMISSION_NORMAL               = 0x00,
+    MESSAGING_CONTROL_TRANSMISSION_NORMAL_AND_ANONYMOUS = 0x01,
+    MESSAGING_CONTROL_TRANSMISSION_ANONYMOUS            = 0x02,
+    MESSAGING_CONTROL_TRANSMISSION_RESERVED             = 0x03,
 };
-}; // namespace LaunchContentResponse
-namespace LaunchURL {
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using MessagingControlTransmission         = EmberAfMessagingControlTransmission;
+#endif
+
+namespace Commands {
+namespace DisplayMessage {
 enum class Fields
 {
-    kContentURL    = 0,
-    kDisplayString = 1,
+    kMessageId                      = 0,
+    kMessageControl                 = 1,
+    kStartTime                      = 2,
+    kDurationInMinutes              = 3,
+    kMessage                        = 4,
+    kOptionalExtendedMessageControl = 5,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LaunchURL::Id; }
-    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+    static constexpr CommandId GetCommandId() { return DisplayMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    Span<const char> contentURL;
-    Span<const char> displayString;
+    uint32_t messageId;
+    uint8_t messageControl;
+    uint32_t startTime;
+    uint16_t durationInMinutes;
+    Span<const char> message;
+    uint8_t optionalExtendedMessageControl;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -11828,30 +20907,29 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return LaunchURL::Id; }
-    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
+    static constexpr CommandId GetCommandId() { return DisplayMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    Span<const char> contentURL;
-    Span<const char> displayString;
+    uint32_t messageId;
+    uint8_t messageControl;
+    uint32_t startTime;
+    uint16_t durationInMinutes;
+    Span<const char> message;
+    uint8_t optionalExtendedMessageControl;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace LaunchURL
-namespace LaunchURLResponse {
+}; // namespace DisplayMessage
+namespace GetLastMessage {
 enum class Fields
 {
-    kData                = 0,
-    kContentLaunchStatus = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LaunchURLResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
-
-    Span<const char> data;
-    ContentLaunchStatus contentLaunchStatus;
+    static constexpr CommandId GetCommandId() { return GetLastMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -11859,74 +20937,28 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return LaunchURLResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ContentLauncher::Id; }
-
-    Span<const char> data;
-    ContentLaunchStatus contentLaunchStatus;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
-};
-}; // namespace LaunchURLResponse
-} // namespace Commands
-} // namespace ContentLauncher
-namespace AudioOutput {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for AudioOutputType
-enum class AudioOutputType : uint8_t
-{
-    AUDIO_OUTPUT_TYPE_HDMI      = 0x00,
-    AUDIO_OUTPUT_TYPE_BT        = 0x01,
-    AUDIO_OUTPUT_TYPE_OPTICAL   = 0x02,
-    AUDIO_OUTPUT_TYPE_HEADPHONE = 0x03,
-    AUDIO_OUTPUT_TYPE_INTERNAL  = 0x04,
-    AUDIO_OUTPUT_TYPE_OTHER     = 0x05,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using AudioOutputType                      = EmberAfAudioOutputType;
-#endif
-
-namespace Structs {
-namespace AudioOutputInfo {
-enum class Fields
-{
-    kIndex      = 0,
-    kOutputType = 1,
-    kName       = 2,
-};
-
-struct Type
-{
-public:
-    uint8_t index;
-    AudioOutputType outputType;
-    chip::ByteSpan name;
+    static constexpr CommandId GetCommandId() { return GetLastMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-
-using DecodableType = Type;
-
-} // namespace AudioOutputInfo
-} // namespace Structs
-
-namespace Commands {
-namespace SelectOutput {
+}; // namespace GetLastMessage
+namespace CancelMessage {
 enum class Fields
 {
-    kIndex = 0,
+    kMessageId      = 0,
+    kMessageControl = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return SelectOutput::Id; }
-    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+    static constexpr CommandId GetCommandId() { return CancelMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    uint8_t index;
+    uint32_t messageId;
+    uint8_t messageControl;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -11934,29 +20966,34 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return SelectOutput::Id; }
-    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+    static constexpr CommandId GetCommandId() { return CancelMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    uint8_t index;
+    uint32_t messageId;
+    uint8_t messageControl;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace SelectOutput
-namespace RenameOutput {
+}; // namespace CancelMessage
+namespace MessageConfirmation {
 enum class Fields
 {
-    kIndex = 0,
-    kName  = 1,
+    kMessageId                  = 0,
+    kConfirmationTime           = 1,
+    kMessageConfirmationControl = 2,
+    kMessageResponse            = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return RenameOutput::Id; }
-    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
+    static constexpr CommandId GetCommandId() { return MessageConfirmation::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    uint8_t index;
-    Span<const char> name;
+    uint32_t messageId;
+    uint32_t confirmationTime;
+    uint8_t messageConfirmationControl;
+    chip::ByteSpan messageResponse;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -11964,73 +21001,40 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return RenameOutput::Id; }
-    static constexpr ClusterId GetClusterId() { return AudioOutput::Id; }
-
-    uint8_t index;
-    Span<const char> name;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
-};
-}; // namespace RenameOutput
-} // namespace Commands
-} // namespace AudioOutput
-namespace ApplicationLauncher {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ApplicationLauncherStatus
-enum class ApplicationLauncherStatus : uint8_t
-{
-    APPLICATION_LAUNCHER_STATUS_SUCCESS           = 0x00,
-    APPLICATION_LAUNCHER_STATUS_APP_NOT_AVAILABLE = 0x01,
-    APPLICATION_LAUNCHER_STATUS_SYSTEM_BUSY       = 0x02,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ApplicationLauncherStatus            = EmberAfApplicationLauncherStatus;
-#endif
-
-namespace Structs {
-namespace ApplicationLauncherApp {
-enum class Fields
-{
-    kCatalogVendorId = 0,
-    kApplicationId   = 1,
-};
-
-struct Type
-{
-public:
-    uint16_t catalogVendorId;
-    Span<const char> applicationId;
+    static constexpr CommandId GetCommandId() { return MessageConfirmation::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    uint32_t messageId;
+    uint32_t confirmationTime;
+    uint8_t messageConfirmationControl;
+    chip::ByteSpan messageResponse;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-
-using DecodableType = Type;
-
-} // namespace ApplicationLauncherApp
-} // namespace Structs
-
-namespace Commands {
-namespace LaunchApp {
+}; // namespace MessageConfirmation
+namespace DisplayProtectedMessage {
 enum class Fields
 {
-    kData            = 0,
-    kCatalogVendorId = 1,
-    kApplicationId   = 2,
+    kMessageId                      = 0,
+    kMessageControl                 = 1,
+    kStartTime                      = 2,
+    kDurationInMinutes              = 3,
+    kMessage                        = 4,
+    kOptionalExtendedMessageControl = 5,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LaunchApp::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+    static constexpr CommandId GetCommandId() { return DisplayProtectedMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    Span<const char> data;
-    uint16_t catalogVendorId;
-    Span<const char> applicationId;
+    uint32_t messageId;
+    uint8_t messageControl;
+    uint32_t startTime;
+    uint16_t durationInMinutes;
+    Span<const char> message;
+    uint8_t optionalExtendedMessageControl;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12038,31 +21042,32 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return LaunchApp::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+    static constexpr CommandId GetCommandId() { return DisplayProtectedMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    Span<const char> data;
-    uint16_t catalogVendorId;
-    Span<const char> applicationId;
+    uint32_t messageId;
+    uint8_t messageControl;
+    uint32_t startTime;
+    uint16_t durationInMinutes;
+    Span<const char> message;
+    uint8_t optionalExtendedMessageControl;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace LaunchApp
-namespace LaunchAppResponse {
+}; // namespace DisplayProtectedMessage
+namespace GetMessageCancellation {
 enum class Fields
 {
-    kStatus = 0,
-    kData   = 1,
+    kEarliestImplementationTime = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LaunchAppResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+    static constexpr CommandId GetCommandId() { return GetMessageCancellation::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    ApplicationLauncherStatus status;
-    Span<const char> data;
+    uint32_t earliestImplementationTime;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12070,47 +21075,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return LaunchAppResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplicationLauncher::Id; }
+    static constexpr CommandId GetCommandId() { return GetMessageCancellation::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    ApplicationLauncherStatus status;
-    Span<const char> data;
+    uint32_t earliestImplementationTime;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace LaunchAppResponse
-} // namespace Commands
-} // namespace ApplicationLauncher
-namespace ApplicationBasic {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for ApplicationBasicStatus
-enum class ApplicationBasicStatus : uint8_t
-{
-    APPLICATION_BASIC_STATUS_STOPPED                  = 0x00,
-    APPLICATION_BASIC_STATUS_ACTIVE_VISIBLE_FOCUS     = 0x01,
-    APPLICATION_BASIC_STATUS_ACTIVE_HIDDEN            = 0x02,
-    APPLICATION_BASIC_STATUS_ACTIVE_VISIBLE_NOT_FOCUS = 0x03,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using ApplicationBasicStatus               = EmberAfApplicationBasicStatus;
-#endif
-
-namespace Commands {
-namespace ChangeStatus {
+}; // namespace GetMessageCancellation
+namespace CancelAllMessages {
 enum class Fields
 {
-    kStatus = 0,
+    kImplementationDateTime = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return ChangeStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr CommandId GetCommandId() { return CancelAllMessages::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    ApplicationBasicStatus status;
+    uint32_t implementationDateTime;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12118,194 +21103,295 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return ChangeStatus::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplicationBasic::Id; }
+    static constexpr CommandId GetCommandId() { return CancelAllMessages::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
-    ApplicationBasicStatus status;
+    uint32_t implementationDateTime;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace ChangeStatus
+}; // namespace CancelAllMessages
 } // namespace Commands
-} // namespace ApplicationBasic
-namespace AccountLogin {
 
-namespace Commands {
-namespace GetSetupPIN {
-enum class Fields
+} // namespace Messaging
+namespace ApplianceIdentification {
+
+namespace Attributes {
+namespace BasicIdentification {
+struct TypeInfo
 {
-    kTempAccountIdentifier = 0,
+    using Type = uint64_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BasicIdentification::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace BasicIdentification
+namespace CompanyName {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetSetupPIN::Id; }
-    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
-
-    Span<const char> tempAccountIdentifier;
-
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CompanyName::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace CompanyName
+namespace CompanyId {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetSetupPIN::Id; }
-    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CompanyId::Id; }
+};
 
-    Span<const char> tempAccountIdentifier;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace CompanyId
+namespace BrandName {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BrandName::Id; }
 };
-}; // namespace GetSetupPIN
-namespace GetSetupPINResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace BrandName
+namespace BrandId {
+struct TypeInfo
 {
-    kSetupPIN = 0,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::BrandId::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace BrandId
+namespace Model {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetSetupPINResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Model::Id; }
+};
 
-    Span<const char> setupPIN;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Model
+namespace PartNumber {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PartNumber::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace PartNumber
+namespace ProductRevision {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductRevision::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductRevision
+namespace SoftwareRevision {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetSetupPINResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareRevision::Id; }
+};
 
-    Span<const char> setupPIN;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace SoftwareRevision
+namespace ProductTypeName {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductTypeName::Id; }
 };
-}; // namespace GetSetupPINResponse
-namespace Login {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductTypeName
+namespace ProductTypeId {
+struct TypeInfo
 {
-    kTempAccountIdentifier = 0,
-    kSetupPIN              = 1,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductTypeId::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductTypeId
+namespace CecedSpecificationVersion {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Login::Id; }
-    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CecedSpecificationVersion::Id; }
+};
 
-    Span<const char> tempAccountIdentifier;
-    Span<const char> setupPIN;
+using DecodableTypeInfo = TypeInfo;
+} // namespace CecedSpecificationVersion
+} // namespace Attributes
+} // namespace ApplianceIdentification
+namespace MeterIdentification {
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+namespace Attributes {
+namespace CompanyName {
+struct TypeInfo
+{
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CompanyName::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace CompanyName
+namespace MeterTypeId {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return Login::Id; }
-    static constexpr ClusterId GetClusterId() { return AccountLogin::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeterTypeId::Id; }
+};
 
-    Span<const char> tempAccountIdentifier;
-    Span<const char> setupPIN;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeterTypeId
+namespace DataQualityId {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DataQualityId::Id; }
 };
-}; // namespace Login
-} // namespace Commands
-} // namespace AccountLogin
-namespace TestCluster {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for SimpleEnum
-enum class SimpleEnum : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DataQualityId
+namespace CustomerName {
+struct TypeInfo
 {
-    SIMPLE_ENUM_UNSPECIFIED = 0x00,
-    SIMPLE_ENUM_VALUE_A     = 0x01,
-    SIMPLE_ENUM_VALUE_B     = 0x02,
-    SIMPLE_ENUM_VALUE_C     = 0x03,
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CustomerName::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using SimpleEnum                           = EmberAfSimpleEnum;
-#endif
 
-namespace Structs {
-namespace SimpleStruct {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace CustomerName
+namespace Model {
+struct TypeInfo
 {
-    kA = 0,
-    kB = 1,
-    kC = 2,
-    kD = 3,
-    kE = 4,
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Model::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Model
+namespace PartNumber {
+struct TypeInfo
 {
-public:
-    uint8_t a;
-    bool b;
-    SimpleEnum c;
-    chip::ByteSpan d;
-    Span<const char> e;
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PartNumber::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace PartNumber
+namespace ProductRevision {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ProductRevision::Id; }
 };
 
-using DecodableType = Type;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ProductRevision
+namespace SoftwareRevision {
+struct TypeInfo
+{
+    using Type = chip::ByteSpan;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareRevision::Id; }
+};
 
-} // namespace SimpleStruct
-namespace NestedStruct {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace SoftwareRevision
+namespace UtilityName {
+struct TypeInfo
 {
-    kA = 0,
-    kB = 1,
-    kC = 2,
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::UtilityName::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace UtilityName
+namespace Pod {
+struct TypeInfo
 {
-public:
-    uint8_t a;
-    bool b;
-    Structs::SimpleStruct::Type c;
+    using Type = Span<const char>;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Pod::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Pod
+namespace AvailablePower {
+struct TypeInfo
+{
+    using Type = int32_t;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AvailablePower::Id; }
 };
 
-using DecodableType = Type;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AvailablePower
+namespace PowerThreshold {
+struct TypeInfo
+{
+    using Type = int32_t;
+    static constexpr ClusterId GetClusterId() { return MeterIdentification::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PowerThreshold::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PowerThreshold
+} // namespace Attributes
+} // namespace MeterIdentification
+namespace ApplianceEventsAndAlert {
+// Need to convert consumers to using the new enum classes, so we
+// don't just have casts all over.
+#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+// Enum for EventIdentification
+enum class EventIdentification : uint8_t
+{
+    EVENT_IDENTIFICATION_END_OF_CYCLE        = 0x01,
+    EVENT_IDENTIFICATION_TEMPERATURE_REACHED = 0x04,
+    EVENT_IDENTIFICATION_END_OF_COOKING      = 0x05,
+    EVENT_IDENTIFICATION_SWITCHING_OFF       = 0x06,
+    EVENT_IDENTIFICATION_WRONG_DATA          = 0x07,
+};
+#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
+using EventIdentification                  = EmberAfEventIdentification;
+#endif
 
-} // namespace NestedStruct
-namespace NestedStructList {
+namespace Commands {
+namespace GetAlerts {
 enum class Fields
 {
-    kA = 0,
-    kB = 1,
-    kC = 2,
-    kD = 3,
-    kE = 4,
-    kF = 5,
-    kG = 6,
 };
 
 struct Type
 {
 public:
-    uint8_t a;
-    bool b;
-    Structs::SimpleStruct::Type c;
-    DataModel::List<Structs::SimpleStruct::Type> d;
-    DataModel::List<uint32_t> e;
-    DataModel::List<chip::ByteSpan> f;
-    DataModel::List<uint8_t> g;
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetAlerts::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12313,27 +21399,26 @@ struct Type
 struct DecodableType
 {
 public:
-    uint8_t a;
-    bool b;
-    Structs::SimpleStruct::DecodableType c;
-    DataModel::DecodableList<Structs::SimpleStruct::DecodableType> d;
-    DataModel::DecodableList<uint32_t> e;
-    DataModel::DecodableList<chip::ByteSpan> f;
-    DataModel::DecodableList<uint8_t> g;
+    static constexpr CommandId GetCommandId() { return GetAlerts::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-
-} // namespace NestedStructList
-namespace DoubleNestedStructList {
+}; // namespace GetAlerts
+namespace GetAlertsResponse {
 enum class Fields
 {
-    kA = 0,
+    kAlertsCount = 0,
 };
 
 struct Type
 {
 public:
-    DataModel::List<Structs::NestedStructList::Type> a;
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetAlertsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+
+    uint8_t alertsCount;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12341,45 +21426,57 @@ struct Type
 struct DecodableType
 {
 public:
-    DataModel::DecodableList<Structs::NestedStructList::DecodableType> a;
+    static constexpr CommandId GetCommandId() { return GetAlertsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+
+    uint8_t alertsCount;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-
-} // namespace DoubleNestedStructList
-namespace TestListStructOctet {
+}; // namespace GetAlertsResponse
+namespace AlertsNotification {
 enum class Fields
 {
-    kFabricIndex     = 0,
-    kOperationalCert = 1,
+    kAlertsCount = 0,
 };
 
 struct Type
 {
 public:
-    uint64_t fabricIndex;
-    chip::ByteSpan operationalCert;
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AlertsNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+
+    uint8_t alertsCount;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
 
-using DecodableType = Type;
-
-} // namespace TestListStructOctet
-} // namespace Structs
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return AlertsNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
 
-namespace Commands {
-namespace Test {
+    uint8_t alertsCount;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AlertsNotification
+namespace EventsNotification {
 enum class Fields
 {
+    kEventHeader = 0,
+    kEventId     = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return Test::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return EventsNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+
+    uint8_t eventHeader;
+    EventIdentification eventId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12387,26 +21484,40 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return Test::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return EventsNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
 
+    uint8_t eventHeader;
+    EventIdentification eventId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace Test
-namespace TestSpecificResponse {
+}; // namespace EventsNotification
+} // namespace Commands
+
+} // namespace ApplianceEventsAndAlert
+namespace ApplianceStatistics {
+
+namespace Commands {
+namespace LogNotification {
 enum class Fields
 {
-    kReturnValue = 0,
+    kTimeStamp  = 0,
+    kLogId      = 1,
+    kLogLength  = 2,
+    kLogPayload = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestSpecificResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
-    uint8_t returnValue;
+    uint32_t timeStamp;
+    uint32_t logId;
+    uint32_t logLength;
+    DataModel::List<uint8_t> logPayload;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12414,24 +21525,30 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestSpecificResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
-    uint8_t returnValue;
+    uint32_t timeStamp;
+    uint32_t logId;
+    uint32_t logLength;
+    DataModel::DecodableList<uint8_t> logPayload;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestSpecificResponse
-namespace TestNotHandled {
+}; // namespace LogNotification
+namespace LogRequest {
 enum class Fields
 {
+    kLogId = 0,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestNotHandled::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+
+    uint32_t logId;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12439,26 +21556,33 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestNotHandled::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
+    uint32_t logId;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestNotHandled
-namespace TestAddArgumentsResponse {
+}; // namespace LogRequest
+namespace LogResponse {
 enum class Fields
 {
-    kReturnValue = 0,
+    kTimeStamp  = 0,
+    kLogId      = 1,
+    kLogLength  = 2,
+    kLogPayload = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestAddArgumentsResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
-    uint8_t returnValue;
+    uint32_t timeStamp;
+    uint32_t logId;
+    uint32_t logLength;
+    DataModel::List<uint8_t> logPayload;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12466,14 +21590,17 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestAddArgumentsResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
-    uint8_t returnValue;
+    uint32_t timeStamp;
+    uint32_t logId;
+    uint32_t logLength;
+    DataModel::DecodableList<uint8_t> logPayload;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestAddArgumentsResponse
-namespace TestSpecific {
+}; // namespace LogResponse
+namespace LogQueueRequest {
 enum class Fields
 {
 };
@@ -12482,8 +21609,8 @@ struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestSpecific::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogQueueRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12491,26 +21618,28 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestSpecific::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogQueueRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestSpecific
-namespace TestSimpleArgumentResponse {
+}; // namespace LogQueueRequest
+namespace LogQueueResponse {
 enum class Fields
 {
-    kReturnValue = 0,
+    kLogQueueSize = 0,
+    kLogIds       = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestSimpleArgumentResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogQueueResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
-    bool returnValue;
+    uint8_t logQueueSize;
+    DataModel::List<uint32_t> logIds;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12518,24 +21647,30 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestSimpleArgumentResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return LogQueueResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
-    bool returnValue;
+    uint8_t logQueueSize;
+    DataModel::DecodableList<uint32_t> logIds;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestSimpleArgumentResponse
-namespace TestUnknownCommand {
+}; // namespace LogQueueResponse
+namespace StatisticsAvailable {
 enum class Fields
 {
+    kLogQueueSize = 0,
+    kLogIds       = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestUnknownCommand::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return StatisticsAvailable::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+
+    uint8_t logQueueSize;
+    DataModel::List<uint32_t> logIds;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12543,36 +21678,62 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestUnknownCommand::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return StatisticsAvailable::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
+    uint8_t logQueueSize;
+    DataModel::DecodableList<uint32_t> logIds;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestUnknownCommand
-namespace TestStructArrayArgumentResponse {
+}; // namespace StatisticsAvailable
+} // namespace Commands
+
+namespace Attributes {
+namespace LogMaxSize {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LogMaxSize::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LogMaxSize
+namespace LogQueueMaxSize {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LogQueueMaxSize::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace LogQueueMaxSize
+} // namespace Attributes
+} // namespace ApplianceStatistics
+namespace ElectricalMeasurement {
+
+namespace Commands {
+namespace GetProfileInfoResponseCommand {
 enum class Fields
 {
-    kArg1 = 0,
-    kArg2 = 1,
-    kArg3 = 2,
-    kArg4 = 3,
-    kArg5 = 4,
-    kArg6 = 5,
+    kProfileCount          = 0,
+    kProfileIntervalPeriod = 1,
+    kMaxNumberOfIntervals  = 2,
+    kListOfAttributes      = 3,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return GetProfileInfoResponseCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
-    DataModel::List<Structs::NestedStructList::Type> arg1;
-    DataModel::List<Structs::SimpleStruct::Type> arg2;
-    DataModel::List<SimpleEnum> arg3;
-    DataModel::List<bool> arg4;
-    SimpleEnum arg5;
-    bool arg6;
+    uint8_t profileCount;
+    uint8_t profileIntervalPeriod;
+    uint8_t maxNumberOfIntervals;
+    DataModel::List<uint16_t> listOfAttributes;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12580,34 +21741,27 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return GetProfileInfoResponseCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
-    DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
-    DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg2;
-    DataModel::DecodableList<SimpleEnum> arg3;
-    DataModel::DecodableList<bool> arg4;
-    SimpleEnum arg5;
-    bool arg6;
+    uint8_t profileCount;
+    uint8_t profileIntervalPeriod;
+    uint8_t maxNumberOfIntervals;
+    DataModel::DecodableList<uint16_t> listOfAttributes;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestStructArrayArgumentResponse
-namespace TestAddArguments {
+}; // namespace GetProfileInfoResponseCommand
+namespace GetProfileInfoCommand {
 enum class Fields
 {
-    kArg1 = 0,
-    kArg2 = 1,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestAddArguments::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
-
-    uint8_t arg1;
-    uint8_t arg2;
+    static constexpr CommandId GetCommandId() { return GetProfileInfoCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12615,28 +21769,36 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestAddArguments::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return GetProfileInfoCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
-    uint8_t arg1;
-    uint8_t arg2;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestAddArguments
-namespace TestSimpleArgumentRequest {
+}; // namespace GetProfileInfoCommand
+namespace GetMeasurementProfileResponseCommand {
 enum class Fields
 {
-    kArg1 = 0,
+    kStartTime                  = 0,
+    kStatus                     = 1,
+    kProfileIntervalPeriod      = 2,
+    kNumberOfIntervalsDelivered = 3,
+    kAttributeId                = 4,
+    kIntervals                  = 5,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestSimpleArgumentRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return GetMeasurementProfileResponseCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
-    bool arg1;
+    uint32_t startTime;
+    uint8_t status;
+    uint8_t profileIntervalPeriod;
+    uint8_t numberOfIntervalsDelivered;
+    uint16_t attributeId;
+    DataModel::List<uint8_t> intervals;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12644,37 +21806,36 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestSimpleArgumentRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return GetMeasurementProfileResponseCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
-    bool arg1;
+    uint32_t startTime;
+    uint8_t status;
+    uint8_t profileIntervalPeriod;
+    uint8_t numberOfIntervalsDelivered;
+    uint16_t attributeId;
+    DataModel::DecodableList<uint8_t> intervals;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestSimpleArgumentRequest
-namespace TestStructArrayArgumentRequest {
+}; // namespace GetMeasurementProfileResponseCommand
+namespace GetMeasurementProfileCommand {
 enum class Fields
 {
-    kArg1 = 0,
-    kArg2 = 1,
-    kArg3 = 2,
-    kArg4 = 3,
-    kArg5 = 4,
-    kArg6 = 5,
+    kAttributeId       = 0,
+    kStartTime         = 1,
+    kNumberOfIntervals = 2,
 };
 
 struct Type
 {
 public:
     // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return GetMeasurementProfileCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
-    DataModel::List<Structs::NestedStructList::Type> arg1;
-    DataModel::List<Structs::SimpleStruct::Type> arg2;
-    DataModel::List<SimpleEnum> arg3;
-    DataModel::List<bool> arg4;
-    SimpleEnum arg5;
-    bool arg6;
+    uint16_t attributeId;
+    uint32_t startTime;
+    uint8_t numberOfIntervals;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
 };
@@ -12682,874 +21843,1299 @@ struct Type
 struct DecodableType
 {
 public:
-    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+    static constexpr CommandId GetCommandId() { return GetMeasurementProfileCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
-    DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
-    DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg2;
-    DataModel::DecodableList<SimpleEnum> arg3;
-    DataModel::DecodableList<bool> arg4;
-    SimpleEnum arg5;
-    bool arg6;
+    uint16_t attributeId;
+    uint32_t startTime;
+    uint8_t numberOfIntervals;
     CHIP_ERROR Decode(TLV::TLVReader & reader);
 };
-}; // namespace TestStructArrayArgumentRequest
+}; // namespace GetMeasurementProfileCommand
 } // namespace Commands
-} // namespace TestCluster
-namespace Messaging {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for EventId
-enum class EventId : uint8_t
-{
-    EVENT_ID_METER_COVER_REMOVED                   = 0x00,
-    EVENT_ID_METER_COVER_CLOSED                    = 0x01,
-    EVENT_ID_STRONG_MAGNETIC_FIELD                 = 0x02,
-    EVENT_ID_NO_STRONG_MAGNETIC_FIELD              = 0x03,
-    EVENT_ID_BATTERY_FAILURE                       = 0x04,
-    EVENT_ID_LOW_BATTERY                           = 0x05,
-    EVENT_ID_PROGRAM_MEMORY_ERROR                  = 0x06,
-    EVENT_ID_RAM_ERROR                             = 0x07,
-    EVENT_ID_NV_MEMORY_ERROR                       = 0x08,
-    EVENT_ID_MEASUREMENT_SYSTEM_ERROR              = 0x09,
-    EVENT_ID_WATCHDOG_ERROR                        = 0x0A,
-    EVENT_ID_SUPPLY_DISCONNECT_FAILURE             = 0x0B,
-    EVENT_ID_SUPPLY_CONNECT_FAILURE                = 0x0C,
-    EVENT_ID_MEASURMENT_SOFTWARE_CHANGED           = 0x0D,
-    EVENT_ID_DST_ENABLED                           = 0x0E,
-    EVENT_ID_DST_DISABLED                          = 0x0F,
-    EVENT_ID_CLOCK_ADJ_BACKWARD                    = 0x10,
-    EVENT_ID_CLOCK_ADJ_FORWARD                     = 0x11,
-    EVENT_ID_CLOCK_INVALID                         = 0x12,
-    EVENT_ID_COMMS_ERROR_HAN                       = 0x13,
-    EVENT_ID_COMMS_OK_HAN                          = 0x14,
-    EVENT_ID_FRAUD_ATTEMPT                         = 0x15,
-    EVENT_ID_POWER_LOSS                            = 0x16,
-    EVENT_ID_INCORRECT_PROTOCOL                    = 0x17,
-    EVENT_ID_UNUSUAL_HAN_TRAFFIC                   = 0x18,
-    EVENT_ID_UNEXPECTED_CLOCK_CHANGE               = 0x19,
-    EVENT_ID_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x1A,
-    EVENT_ID_ERROR_REG_CLEAR                       = 0x1B,
-    EVENT_ID_ALARM_REG_CLEAR                       = 0x1C,
-    EVENT_ID_UNEXPECTED_HW_RESET                   = 0x1D,
-    EVENT_ID_UNEXPECTED_PROGRAM_EXECUTION          = 0x1E,
-    EVENT_ID_EVENT_LOG_CLEARED                     = 0x1F,
-    EVENT_ID_MANUAL_DISCONNECT                     = 0x20,
-    EVENT_ID_MANUAL_CONNECT                        = 0x21,
-    EVENT_ID_REMOTE_DISCONNECTION                  = 0x22,
-    EVENT_ID_LOCAL_DISCONNECTION                   = 0x23,
-    EVENT_ID_LIMIT_THRESHOLD_EXCEEDED              = 0x24,
-    EVENT_ID_LIMIT_THRESHOLD_OK                    = 0x25,
-    EVENT_ID_LIMIT_THRESHOLD_CHANGED               = 0x26,
-    EVENT_ID_MAXIMUM_DEMAND_EXCEEDED               = 0x27,
-    EVENT_ID_PROFILE_CLEARED                       = 0x28,
-    EVENT_ID_FIRMWARE_READY_FOR_ACTIVATION         = 0x29,
-    EVENT_ID_FIRMWARE_ACTIVATED                    = 0x2A,
-    EVENT_ID_PATCH_FAILURE                         = 0x2B,
-    EVENT_ID_TOU_TARIFF_ACTIVATION                 = 0x2C,
-    EVENT_ID_8X8_TARIFFACTIVATED                   = 0x2D,
-    EVENT_ID_SINGLE_TARIFF_RATE_ACTIVATED          = 0x2E,
-    EVENT_ID_ASYNCHRONOUS_BILLING_OCCURRED         = 0x2F,
-    EVENT_ID_SYNCHRONOUS_BILLING_OCCURRED          = 0x30,
-    EVENT_ID_INCORRECT_POLARITY                    = 0x80,
-    EVENT_ID_CURRENT_NO_VOLTAGE                    = 0x81,
-    EVENT_ID_UNDER_VOLTAGE                         = 0x82,
-    EVENT_ID_OVER_VOLTAGE                          = 0x83,
-    EVENT_ID_NORMAL_VOLTAGE                        = 0x84,
-    EVENT_ID_PF_BELOW_THRESHOLD                    = 0x85,
-    EVENT_ID_PF_ABOVE_THRESHOLD                    = 0x86,
-    EVENT_ID_TERMINAL_COVER_REMOVED                = 0x87,
-    EVENT_ID_TERMINAL_COVER_CLOSED                 = 0x88,
-    EVENT_ID_REVERSE_FLOW                          = 0xA0,
-    EVENT_ID_TILT_TAMPER                           = 0xA1,
-    EVENT_ID_BATTERY_COVER_REMOVED                 = 0xA2,
-    EVENT_ID_BATTERY_COVER_CLOSED                  = 0xA3,
-    EVENT_ID_EXCESS_FLOW                           = 0xA4,
-    EVENT_ID_CREDIT_OK                             = 0xC0,
-    EVENT_ID_LOW_CREDIT                            = 0xC1,
-    EVENT_ID_EMERGENCY_CREDIT_IN_USE               = 0xC0,
-    EVENT_ID_EMERGENCY_CREDIT_EXHAUSTED            = 0xC1,
-    EVENT_ID_ZERO_CREDIT_EC_NOT_SELECTED           = 0xC2,
-    EVENT_ID_SUPPLY_ON                             = 0xC3,
-    EVENT_ID_SUPPLY_OFF_AARMED                     = 0xC4,
-    EVENT_ID_SUPPLY_OFF                            = 0xC5,
-    EVENT_ID_DISCOUNT_APPLIED                      = 0xC6,
-    EVENT_ID_MANUFACTURER_SPECIFIC_A               = 0xE0,
-    EVENT_ID_MANUFACTURER_SPECIFIC_B               = 0xE1,
-    EVENT_ID_MANUFACTURER_SPECIFIC_C               = 0xE2,
-    EVENT_ID_MANUFACTURER_SPECIFIC_D               = 0xE3,
-    EVENT_ID_MANUFACTURER_SPECIFIC_E               = 0xE4,
-    EVENT_ID_MANUFACTURER_SPECIFIC_F               = 0xE5,
-    EVENT_ID_MANUFACTURER_SPECIFIC_G               = 0xE6,
-    EVENT_ID_MANUFACTURER_SPECIFIC_H               = 0xE7,
-    EVENT_ID_MANUFACTURER_SPECIFIC_I               = 0xE8,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using EventId                              = EmberAfEventId;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for MessagingControlConfirmation
-enum class MessagingControlConfirmation : uint8_t
-{
-    MESSAGING_CONTROL_CONFIRMATION_NOT_REQUIRED = 0x00,
-    MESSAGING_CONTROL_CONFIRMATION_REQUIRED     = 0x80,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using MessagingControlConfirmation         = EmberAfMessagingControlConfirmation;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for MessagingControlEnhancedConfirmation
-enum class MessagingControlEnhancedConfirmation : uint8_t
-{
-    MESSAGING_CONTROL_ENHANCED_CONFIRMATION_NOT_REQUIRED = 0x00,
-    MESSAGING_CONTROL_ENHANCED_CONFIRMATION_REQUIRED     = 0x20,
-};
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using MessagingControlEnhancedConfirmation = EmberAfMessagingControlEnhancedConfirmation;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for MessagingControlImportance
-enum class MessagingControlImportance : uint8_t
+
+namespace Attributes {
+namespace MeasurementType {
+struct TypeInfo
 {
-    MESSAGING_CONTROL_IMPORTANCE_LOW      = 0x00,
-    MESSAGING_CONTROL_IMPORTANCE_MEDIUM   = 0x04,
-    MESSAGING_CONTROL_IMPORTANCE_HIGH     = 0x08,
-    MESSAGING_CONTROL_IMPORTANCE_CRITICAL = 0x0C,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementType::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using MessagingControlImportance           = EmberAfMessagingControlImportance;
-#endif
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for MessagingControlTransmission
-enum class MessagingControlTransmission : uint8_t
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasurementType
+namespace DcVoltage {
+struct TypeInfo
 {
-    MESSAGING_CONTROL_TRANSMISSION_NORMAL               = 0x00,
-    MESSAGING_CONTROL_TRANSMISSION_NORMAL_AND_ANONYMOUS = 0x01,
-    MESSAGING_CONTROL_TRANSMISSION_ANONYMOUS            = 0x02,
-    MESSAGING_CONTROL_TRANSMISSION_RESERVED             = 0x03,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcVoltage::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using MessagingControlTransmission         = EmberAfMessagingControlTransmission;
-#endif
 
-namespace Commands {
-namespace DisplayMessage {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcVoltage
+namespace DcVoltageMin {
+struct TypeInfo
 {
-    kMessageId                      = 0,
-    kMessageControl                 = 1,
-    kStartTime                      = 2,
-    kDurationInMinutes              = 3,
-    kMessage                        = 4,
-    kOptionalExtendedMessageControl = 5,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcVoltageMin::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcVoltageMin
+namespace DcVoltageMax {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return DisplayMessage::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcVoltageMax::Id; }
+};
 
-    uint32_t messageId;
-    uint8_t messageControl;
-    uint32_t startTime;
-    uint16_t durationInMinutes;
-    Span<const char> message;
-    uint8_t optionalExtendedMessageControl;
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcVoltageMax
+namespace DcCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcCurrent::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcCurrent
+namespace DcCurrentMin {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcCurrentMin::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcCurrentMin
+namespace DcCurrentMax {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return DisplayMessage::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcCurrentMax::Id; }
+};
 
-    uint32_t messageId;
-    uint8_t messageControl;
-    uint32_t startTime;
-    uint16_t durationInMinutes;
-    Span<const char> message;
-    uint8_t optionalExtendedMessageControl;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcCurrentMax
+namespace DcPower {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcPower::Id; }
 };
-}; // namespace DisplayMessage
-namespace GetLastMessage {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcPower
+namespace DcPowerMin {
+struct TypeInfo
 {
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcPowerMin::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcPowerMin
+namespace DcPowerMax {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetLastMessage::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcPowerMax::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcPowerMax
+namespace DcVoltageMultiplier {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcVoltageMultiplier::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcVoltageMultiplier
+namespace DcVoltageDivisor {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetLastMessage::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcVoltageDivisor::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcVoltageDivisor
+namespace DcCurrentMultiplier {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcCurrentMultiplier::Id; }
 };
-}; // namespace GetLastMessage
-namespace CancelMessage {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcCurrentMultiplier
+namespace DcCurrentDivisor {
+struct TypeInfo
 {
-    kMessageId      = 0,
-    kMessageControl = 1,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcCurrentDivisor::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcCurrentDivisor
+namespace DcPowerMultiplier {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return CancelMessage::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcPowerMultiplier::Id; }
+};
 
-    uint32_t messageId;
-    uint8_t messageControl;
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcPowerMultiplier
+namespace DcPowerDivisor {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::DcPowerDivisor::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace DcPowerDivisor
+namespace AcFrequency {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcFrequency::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcFrequency
+namespace AcFrequencyMin {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return CancelMessage::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcFrequencyMin::Id; }
+};
 
-    uint32_t messageId;
-    uint8_t messageControl;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcFrequencyMin
+namespace AcFrequencyMax {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcFrequencyMax::Id; }
 };
-}; // namespace CancelMessage
-namespace MessageConfirmation {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcFrequencyMax
+namespace NeutralCurrent {
+struct TypeInfo
 {
-    kMessageId                  = 0,
-    kConfirmationTime           = 1,
-    kMessageConfirmationControl = 2,
-    kMessageResponse            = 3,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::NeutralCurrent::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace NeutralCurrent
+namespace TotalActivePower {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return MessageConfirmation::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int32_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TotalActivePower::Id; }
+};
 
-    uint32_t messageId;
-    uint32_t confirmationTime;
-    uint8_t messageConfirmationControl;
-    chip::ByteSpan messageResponse;
+using DecodableTypeInfo = TypeInfo;
+} // namespace TotalActivePower
+namespace TotalReactivePower {
+struct TypeInfo
+{
+    using Type = int32_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TotalReactivePower::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace TotalReactivePower
+namespace TotalApparentPower {
+struct TypeInfo
+{
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::TotalApparentPower::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace TotalApparentPower
+namespace Measured1stHarmonicCurrent {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return MessageConfirmation::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Measured1stHarmonicCurrent::Id; }
+};
 
-    uint32_t messageId;
-    uint32_t confirmationTime;
-    uint8_t messageConfirmationControl;
-    chip::ByteSpan messageResponse;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace Measured1stHarmonicCurrent
+namespace Measured3rdHarmonicCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Measured3rdHarmonicCurrent::Id; }
 };
-}; // namespace MessageConfirmation
-namespace DisplayProtectedMessage {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace Measured3rdHarmonicCurrent
+namespace Measured5thHarmonicCurrent {
+struct TypeInfo
 {
-    kMessageId                      = 0,
-    kMessageControl                 = 1,
-    kStartTime                      = 2,
-    kDurationInMinutes              = 3,
-    kMessage                        = 4,
-    kOptionalExtendedMessageControl = 5,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Measured5thHarmonicCurrent::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace Measured5thHarmonicCurrent
+namespace Measured7thHarmonicCurrent {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return DisplayProtectedMessage::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Measured7thHarmonicCurrent::Id; }
+};
 
-    uint32_t messageId;
-    uint8_t messageControl;
-    uint32_t startTime;
-    uint16_t durationInMinutes;
-    Span<const char> message;
-    uint8_t optionalExtendedMessageControl;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Measured7thHarmonicCurrent
+namespace Measured9thHarmonicCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Measured9thHarmonicCurrent::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace Measured9thHarmonicCurrent
+namespace Measured11thHarmonicCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Measured11thHarmonicCurrent::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace Measured11thHarmonicCurrent
+namespace MeasuredPhase1stHarmonicCurrent {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return DisplayProtectedMessage::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredPhase1stHarmonicCurrent::Id; }
+};
 
-    uint32_t messageId;
-    uint8_t messageControl;
-    uint32_t startTime;
-    uint16_t durationInMinutes;
-    Span<const char> message;
-    uint8_t optionalExtendedMessageControl;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredPhase1stHarmonicCurrent
+namespace MeasuredPhase3rdHarmonicCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredPhase3rdHarmonicCurrent::Id; }
 };
-}; // namespace DisplayProtectedMessage
-namespace GetMessageCancellation {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredPhase3rdHarmonicCurrent
+namespace MeasuredPhase5thHarmonicCurrent {
+struct TypeInfo
 {
-    kEarliestImplementationTime = 0,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredPhase5thHarmonicCurrent::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredPhase5thHarmonicCurrent
+namespace MeasuredPhase7thHarmonicCurrent {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetMessageCancellation::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredPhase7thHarmonicCurrent::Id; }
+};
 
-    uint32_t earliestImplementationTime;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredPhase7thHarmonicCurrent
+namespace MeasuredPhase9thHarmonicCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredPhase9thHarmonicCurrent::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredPhase9thHarmonicCurrent
+namespace MeasuredPhase11thHarmonicCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredPhase11thHarmonicCurrent::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace MeasuredPhase11thHarmonicCurrent
+namespace AcFrequencyMultiplier {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetMessageCancellation::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcFrequencyMultiplier::Id; }
+};
 
-    uint32_t earliestImplementationTime;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcFrequencyMultiplier
+namespace AcFrequencyDivisor {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcFrequencyDivisor::Id; }
 };
-}; // namespace GetMessageCancellation
-namespace CancelAllMessages {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcFrequencyDivisor
+namespace PowerMultiplier {
+struct TypeInfo
 {
-    kImplementationDateTime = 0,
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PowerMultiplier::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace PowerMultiplier
+namespace PowerDivisor {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return CancelAllMessages::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = uint32_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PowerDivisor::Id; }
+};
 
-    uint32_t implementationDateTime;
+using DecodableTypeInfo = TypeInfo;
+} // namespace PowerDivisor
+namespace HarmonicCurrentMultiplier {
+struct TypeInfo
+{
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::HarmonicCurrentMultiplier::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace HarmonicCurrentMultiplier
+namespace PhaseHarmonicCurrentMultiplier {
+struct TypeInfo
+{
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PhaseHarmonicCurrentMultiplier::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace PhaseHarmonicCurrentMultiplier
+namespace InstantaneousVoltage {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return CancelAllMessages::Id; }
-    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstantaneousVoltage::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstantaneousVoltage
+namespace InstantaneousLineCurrent {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstantaneousLineCurrent::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstantaneousLineCurrent
+namespace InstantaneousActiveCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstantaneousActiveCurrent::Id; }
+};
 
-    uint32_t implementationDateTime;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstantaneousActiveCurrent
+namespace InstantaneousReactiveCurrent {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstantaneousReactiveCurrent::Id; }
 };
-}; // namespace CancelAllMessages
-} // namespace Commands
-} // namespace Messaging
-namespace ApplianceIdentification {
 
-} // namespace ApplianceIdentification
-namespace MeterIdentification {
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstantaneousReactiveCurrent
+namespace InstantaneousPower {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::InstantaneousPower::Id; }
+};
 
-} // namespace MeterIdentification
-namespace ApplianceEventsAndAlert {
-// Need to convert consumers to using the new enum classes, so we
-// don't just have casts all over.
-#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-// Enum for EventIdentification
-enum class EventIdentification : uint8_t
+using DecodableTypeInfo = TypeInfo;
+} // namespace InstantaneousPower
+namespace RmsVoltage {
+struct TypeInfo
 {
-    EVENT_IDENTIFICATION_END_OF_CYCLE        = 0x01,
-    EVENT_IDENTIFICATION_TEMPERATURE_REACHED = 0x04,
-    EVENT_IDENTIFICATION_END_OF_COOKING      = 0x05,
-    EVENT_IDENTIFICATION_SWITCHING_OFF       = 0x06,
-    EVENT_IDENTIFICATION_WRONG_DATA          = 0x07,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltage::Id; }
 };
-#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
-using EventIdentification                  = EmberAfEventIdentification;
-#endif
 
-namespace Commands {
-namespace GetAlerts {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltage
+namespace RmsVoltageMin {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageMin::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageMin
+namespace RmsVoltageMax {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetAlerts::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageMax::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageMax
+namespace RmsCurrent {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrent::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrent
+namespace RmsCurrentMin {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetAlerts::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrentMin::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrentMin
+namespace RmsCurrentMax {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrentMax::Id; }
 };
-}; // namespace GetAlerts
-namespace GetAlertsResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrentMax
+namespace ActivePower {
+struct TypeInfo
 {
-    kAlertsCount = 0,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePower::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePower
+namespace ActivePowerMin {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetAlertsResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePowerMin::Id; }
+};
 
-    uint8_t alertsCount;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePowerMin
+namespace ActivePowerMax {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePowerMax::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePowerMax
+namespace ReactivePower {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ReactivePower::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ReactivePower
+namespace ApparentPower {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetAlertsResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApparentPower::Id; }
+};
 
-    uint8_t alertsCount;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ApparentPower
+namespace PowerFactor {
+struct TypeInfo
+{
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PowerFactor::Id; }
 };
-}; // namespace GetAlertsResponse
-namespace AlertsNotification {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PowerFactor
+namespace AverageRmsVoltageMeasurementPeriod {
+struct TypeInfo
 {
-    kAlertsCount = 0,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsVoltageMeasurementPeriod::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsVoltageMeasurementPeriod
+namespace AverageRmsUnderVoltageCounter {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return AlertsNotification::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsUnderVoltageCounter::Id; }
+};
 
-    uint8_t alertsCount;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsUnderVoltageCounter
+namespace RmsExtremeOverVoltagePeriod {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsExtremeOverVoltagePeriod::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsExtremeOverVoltagePeriod
+namespace RmsExtremeUnderVoltagePeriod {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsExtremeUnderVoltagePeriod::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsExtremeUnderVoltagePeriod
+namespace RmsVoltageSagPeriod {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return AlertsNotification::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageSagPeriod::Id; }
+};
 
-    uint8_t alertsCount;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageSagPeriod
+namespace RmsVoltageSwellPeriod {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageSwellPeriod::Id; }
 };
-}; // namespace AlertsNotification
-namespace EventsNotification {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageSwellPeriod
+namespace AcVoltageMultiplier {
+struct TypeInfo
 {
-    kEventHeader = 0,
-    kEventId     = 1,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcVoltageMultiplier::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcVoltageMultiplier
+namespace AcVoltageDivisor {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return EventsNotification::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcVoltageDivisor::Id; }
+};
 
-    uint8_t eventHeader;
-    EventIdentification eventId;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcVoltageDivisor
+namespace AcCurrentMultiplier {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcCurrentMultiplier::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcCurrentMultiplier
+namespace AcCurrentDivisor {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcCurrentDivisor::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcCurrentDivisor
+namespace AcPowerMultiplier {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return EventsNotification::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcPowerMultiplier::Id; }
+};
 
-    uint8_t eventHeader;
-    EventIdentification eventId;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcPowerMultiplier
+namespace AcPowerDivisor {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcPowerDivisor::Id; }
 };
-}; // namespace EventsNotification
-} // namespace Commands
-} // namespace ApplianceEventsAndAlert
-namespace ApplianceStatistics {
 
-namespace Commands {
-namespace LogNotification {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcPowerDivisor
+namespace OverloadAlarmsMask {
+struct TypeInfo
 {
-    kTimeStamp  = 0,
-    kLogId      = 1,
-    kLogLength  = 2,
-    kLogPayload = 3,
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::OverloadAlarmsMask::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace OverloadAlarmsMask
+namespace VoltageOverload {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LogNotification::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::VoltageOverload::Id; }
+};
 
-    uint32_t timeStamp;
-    uint32_t logId;
-    uint32_t logLength;
-    DataModel::List<uint8_t> logPayload;
+using DecodableTypeInfo = TypeInfo;
+} // namespace VoltageOverload
+namespace CurrentOverload {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::CurrentOverload::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace CurrentOverload
+namespace AcOverloadAlarmsMask {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcOverloadAlarmsMask::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcOverloadAlarmsMask
+namespace AcVoltageOverload {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return LogNotification::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcVoltageOverload::Id; }
+};
 
-    uint32_t timeStamp;
-    uint32_t logId;
-    uint32_t logLength;
-    DataModel::DecodableList<uint8_t> logPayload;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcVoltageOverload
+namespace AcCurrentOverload {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcCurrentOverload::Id; }
 };
-}; // namespace LogNotification
-namespace LogRequest {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcCurrentOverload
+namespace AcActivePowerOverload {
+struct TypeInfo
 {
-    kLogId = 0,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcActivePowerOverload::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcActivePowerOverload
+namespace AcReactivePowerOverload {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LogRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AcReactivePowerOverload::Id; }
+};
 
-    uint32_t logId;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AcReactivePowerOverload
+namespace AverageRmsOverVoltage {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsOverVoltage::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsOverVoltage
+namespace AverageRmsUnderVoltage {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsUnderVoltage::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsUnderVoltage
+namespace RmsExtremeOverVoltage {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return LogRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsExtremeOverVoltage::Id; }
+};
 
-    uint32_t logId;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsExtremeOverVoltage
+namespace RmsExtremeUnderVoltage {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsExtremeUnderVoltage::Id; }
 };
-}; // namespace LogRequest
-namespace LogResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsExtremeUnderVoltage
+namespace RmsVoltageSag {
+struct TypeInfo
 {
-    kTimeStamp  = 0,
-    kLogId      = 1,
-    kLogLength  = 2,
-    kLogPayload = 3,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageSag::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageSag
+namespace RmsVoltageSwell {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LogResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageSwell::Id; }
+};
 
-    uint32_t timeStamp;
-    uint32_t logId;
-    uint32_t logLength;
-    DataModel::List<uint8_t> logPayload;
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageSwell
+namespace LineCurrentPhaseB {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LineCurrentPhaseB::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace LineCurrentPhaseB
+namespace ActiveCurrentPhaseB {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveCurrentPhaseB::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActiveCurrentPhaseB
+namespace ReactiveCurrentPhaseB {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return LogResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ReactiveCurrentPhaseB::Id; }
+};
 
-    uint32_t timeStamp;
-    uint32_t logId;
-    uint32_t logLength;
-    DataModel::DecodableList<uint8_t> logPayload;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ReactiveCurrentPhaseB
+namespace RmsVoltagePhaseB {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltagePhaseB::Id; }
 };
-}; // namespace LogResponse
-namespace LogQueueRequest {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltagePhaseB
+namespace RmsVoltageMinPhaseB {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageMinPhaseB::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageMinPhaseB
+namespace RmsVoltageMaxPhaseB {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LogQueueRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageMaxPhaseB::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageMaxPhaseB
+namespace RmsCurrentPhaseB {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrentPhaseB::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrentPhaseB
+namespace RmsCurrentMinPhaseB {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return LogQueueRequest::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrentMinPhaseB::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrentMinPhaseB
+namespace RmsCurrentMaxPhaseB {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrentMaxPhaseB::Id; }
 };
-}; // namespace LogQueueRequest
-namespace LogQueueResponse {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrentMaxPhaseB
+namespace ActivePowerPhaseB {
+struct TypeInfo
 {
-    kLogQueueSize = 0,
-    kLogIds       = 1,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePowerPhaseB::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePowerPhaseB
+namespace ActivePowerMinPhaseB {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return LogQueueResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePowerMinPhaseB::Id; }
+};
 
-    uint8_t logQueueSize;
-    DataModel::List<uint32_t> logIds;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePowerMinPhaseB
+namespace ActivePowerMaxPhaseB {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePowerMaxPhaseB::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePowerMaxPhaseB
+namespace ReactivePowerPhaseB {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ReactivePowerPhaseB::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ReactivePowerPhaseB
+namespace ApparentPowerPhaseB {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return LogQueueResponse::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApparentPowerPhaseB::Id; }
+};
 
-    uint8_t logQueueSize;
-    DataModel::DecodableList<uint32_t> logIds;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace ApparentPowerPhaseB
+namespace PowerFactorPhaseB {
+struct TypeInfo
+{
+    using Type = int8_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PowerFactorPhaseB::Id; }
 };
-}; // namespace LogQueueResponse
-namespace StatisticsAvailable {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace PowerFactorPhaseB
+namespace AverageRmsVoltageMeasurementPeriodPhaseB {
+struct TypeInfo
 {
-    kLogQueueSize = 0,
-    kLogIds       = 1,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsVoltageMeasurementPeriodPhaseB
+namespace AverageRmsOverVoltageCounterPhaseB {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return StatisticsAvailable::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsOverVoltageCounterPhaseB::Id; }
+};
 
-    uint8_t logQueueSize;
-    DataModel::List<uint32_t> logIds;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsOverVoltageCounterPhaseB
+namespace AverageRmsUnderVoltageCounterPhaseB {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsUnderVoltageCounterPhaseB::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsUnderVoltageCounterPhaseB
+namespace RmsExtremeOverVoltagePeriodPhaseB {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsExtremeOverVoltagePeriodPhaseB::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsExtremeOverVoltagePeriodPhaseB
+namespace RmsExtremeUnderVoltagePeriodPhaseB {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return StatisticsAvailable::Id; }
-    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsExtremeUnderVoltagePeriodPhaseB::Id; }
+};
 
-    uint8_t logQueueSize;
-    DataModel::DecodableList<uint32_t> logIds;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsExtremeUnderVoltagePeriodPhaseB
+namespace RmsVoltageSagPeriodPhaseB {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageSagPeriodPhaseB::Id; }
 };
-}; // namespace StatisticsAvailable
-} // namespace Commands
-} // namespace ApplianceStatistics
-namespace ElectricalMeasurement {
 
-namespace Commands {
-namespace GetProfileInfoResponseCommand {
-enum class Fields
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageSagPeriodPhaseB
+namespace RmsVoltageSwellPeriodPhaseB {
+struct TypeInfo
 {
-    kProfileCount          = 0,
-    kProfileIntervalPeriod = 1,
-    kMaxNumberOfIntervals  = 2,
-    kListOfAttributes      = 3,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageSwellPeriodPhaseB::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageSwellPeriodPhaseB
+namespace LineCurrentPhaseC {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetProfileInfoResponseCommand::Id; }
+    using Type = uint16_t;
     static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::LineCurrentPhaseC::Id; }
+};
 
-    uint8_t profileCount;
-    uint8_t profileIntervalPeriod;
-    uint8_t maxNumberOfIntervals;
-    DataModel::List<uint16_t> listOfAttributes;
+using DecodableTypeInfo = TypeInfo;
+} // namespace LineCurrentPhaseC
+namespace ActiveCurrentPhaseC {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveCurrentPhaseC::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActiveCurrentPhaseC
+namespace ReactiveCurrentPhaseC {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ReactiveCurrentPhaseC::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ReactiveCurrentPhaseC
+namespace RmsVoltagePhaseC {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetProfileInfoResponseCommand::Id; }
+    using Type = uint16_t;
     static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltagePhaseC::Id; }
+};
 
-    uint8_t profileCount;
-    uint8_t profileIntervalPeriod;
-    uint8_t maxNumberOfIntervals;
-    DataModel::DecodableList<uint16_t> listOfAttributes;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltagePhaseC
+namespace RmsVoltageMinPhaseC {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageMinPhaseC::Id; }
 };
-}; // namespace GetProfileInfoResponseCommand
-namespace GetProfileInfoCommand {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageMinPhaseC
+namespace RmsVoltageMaxPhaseC {
+struct TypeInfo
 {
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageMaxPhaseC::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageMaxPhaseC
+namespace RmsCurrentPhaseC {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetProfileInfoCommand::Id; }
+    using Type = uint16_t;
     static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrentPhaseC::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrentPhaseC
+namespace RmsCurrentMinPhaseC {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrentMinPhaseC::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrentMinPhaseC
+namespace RmsCurrentMaxPhaseC {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetProfileInfoCommand::Id; }
+    using Type = uint16_t;
     static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsCurrentMaxPhaseC::Id; }
+};
 
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsCurrentMaxPhaseC
+namespace ActivePowerPhaseC {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePowerPhaseC::Id; }
 };
-}; // namespace GetProfileInfoCommand
-namespace GetMeasurementProfileResponseCommand {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePowerPhaseC
+namespace ActivePowerMinPhaseC {
+struct TypeInfo
 {
-    kStartTime                  = 0,
-    kStatus                     = 1,
-    kProfileIntervalPeriod      = 2,
-    kNumberOfIntervalsDelivered = 3,
-    kAttributeId                = 4,
-    kIntervals                  = 5,
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePowerMinPhaseC::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePowerMinPhaseC
+namespace ActivePowerMaxPhaseC {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetMeasurementProfileResponseCommand::Id; }
+    using Type = int16_t;
     static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ActivePowerMaxPhaseC::Id; }
+};
 
-    uint32_t startTime;
-    uint8_t status;
-    uint8_t profileIntervalPeriod;
-    uint8_t numberOfIntervalsDelivered;
-    uint16_t attributeId;
-    DataModel::List<uint8_t> intervals;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ActivePowerMaxPhaseC
+namespace ReactivePowerPhaseC {
+struct TypeInfo
+{
+    using Type = int16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ReactivePowerPhaseC::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace ReactivePowerPhaseC
+namespace ApparentPowerPhaseC {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::ApparentPowerPhaseC::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace ApparentPowerPhaseC
+namespace PowerFactorPhaseC {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetMeasurementProfileResponseCommand::Id; }
+    using Type = int8_t;
     static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::PowerFactorPhaseC::Id; }
+};
 
-    uint32_t startTime;
-    uint8_t status;
-    uint8_t profileIntervalPeriod;
-    uint8_t numberOfIntervalsDelivered;
-    uint16_t attributeId;
-    DataModel::DecodableList<uint8_t> intervals;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace PowerFactorPhaseC
+namespace AverageRmsVoltageMeasurementPeriodPhaseC {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::Id; }
 };
-}; // namespace GetMeasurementProfileResponseCommand
-namespace GetMeasurementProfileCommand {
-enum class Fields
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsVoltageMeasurementPeriodPhaseC
+namespace AverageRmsOverVoltageCounterPhaseC {
+struct TypeInfo
 {
-    kAttributeId       = 0,
-    kStartTime         = 1,
-    kNumberOfIntervals = 2,
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsOverVoltageCounterPhaseC::Id; }
 };
 
-struct Type
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsOverVoltageCounterPhaseC
+namespace AverageRmsUnderVoltageCounterPhaseC {
+struct TypeInfo
 {
-public:
-    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
-    static constexpr CommandId GetCommandId() { return GetMeasurementProfileCommand::Id; }
+    using Type = uint16_t;
     static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::AverageRmsUnderVoltageCounterPhaseC::Id; }
+};
 
-    uint16_t attributeId;
-    uint32_t startTime;
-    uint8_t numberOfIntervals;
+using DecodableTypeInfo = TypeInfo;
+} // namespace AverageRmsUnderVoltageCounterPhaseC
+namespace RmsExtremeOverVoltagePeriodPhaseC {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsExtremeOverVoltagePeriodPhaseC::Id; }
+};
 
-    CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsExtremeOverVoltagePeriodPhaseC
+namespace RmsExtremeUnderVoltagePeriodPhaseC {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsExtremeUnderVoltagePeriodPhaseC::Id; }
 };
 
-struct DecodableType
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsExtremeUnderVoltagePeriodPhaseC
+namespace RmsVoltageSagPeriodPhaseC {
+struct TypeInfo
 {
-public:
-    static constexpr CommandId GetCommandId() { return GetMeasurementProfileCommand::Id; }
+    using Type = uint16_t;
     static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageSagPeriodPhaseC::Id; }
+};
 
-    uint16_t attributeId;
-    uint32_t startTime;
-    uint8_t numberOfIntervals;
-    CHIP_ERROR Decode(TLV::TLVReader & reader);
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageSagPeriodPhaseC
+namespace RmsVoltageSwellPeriodPhaseC {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::RmsVoltageSwellPeriodPhaseC::Id; }
 };
-}; // namespace GetMeasurementProfileCommand
-} // namespace Commands
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace RmsVoltageSwellPeriodPhaseC
+} // namespace Attributes
 } // namespace ElectricalMeasurement
 namespace Binding {
 
@@ -13629,6 +23215,7 @@ struct DecodableType
 };
 }; // namespace Unbind
 } // namespace Commands
+
 } // namespace Binding
 namespace GroupKeyManagement {
 // Need to convert consumers to using the new enum classes, so we
@@ -13695,6 +23282,38 @@ using DecodableType = Type;
 } // namespace GroupState
 } // namespace Structs
 
+namespace Attributes {
+namespace Groups {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::GroupState::Type>;
+    static constexpr ClusterId GetClusterId() { return GroupKeyManagement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Groups::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::GroupState::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return GroupKeyManagement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::Groups::Id; }
+};
+} // namespace Groups
+namespace GroupKeys {
+struct TypeInfo
+{
+    using Type = DataModel::List<Structs::GroupKey::Type>;
+    static constexpr ClusterId GetClusterId() { return GroupKeyManagement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::GroupKeys::Id; }
+};
+
+struct DecodableTypeInfo
+{
+    using Type = DataModel::DecodableList<Structs::GroupKey::DecodableType>;
+    static constexpr ClusterId GetClusterId() { return GroupKeyManagement::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::GroupKeys::Id; }
+};
+} // namespace GroupKeys
+} // namespace Attributes
 } // namespace GroupKeyManagement
 namespace SampleMfgSpecificCluster {
 
@@ -13728,6 +23347,29 @@ struct DecodableType
 };
 }; // namespace CommandOne
 } // namespace Commands
+
+namespace Attributes {
+namespace EmberSampleAttribute {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return SampleMfgSpecificCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EmberSampleAttribute::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EmberSampleAttribute
+namespace EmberSampleAttribute2 {
+struct TypeInfo
+{
+    using Type = uint8_t;
+    static constexpr ClusterId GetClusterId() { return SampleMfgSpecificCluster::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EmberSampleAttribute2::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EmberSampleAttribute2
+} // namespace Attributes
 } // namespace SampleMfgSpecificCluster
 namespace SampleMfgSpecificCluster2 {
 
@@ -13761,6 +23403,29 @@ struct DecodableType
 };
 }; // namespace CommandTwo
 } // namespace Commands
+
+namespace Attributes {
+namespace EmberSampleAttribute3 {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return SampleMfgSpecificCluster2::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EmberSampleAttribute3::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EmberSampleAttribute3
+namespace EmberSampleAttribute4 {
+struct TypeInfo
+{
+    using Type = uint16_t;
+    static constexpr ClusterId GetClusterId() { return SampleMfgSpecificCluster2::Id; }
+    static constexpr AttributeId GetAttributeId() { return Attributes::EmberSampleAttribute4::Id; }
+};
+
+using DecodableTypeInfo = TypeInfo;
+} // namespace EmberSampleAttribute4
+} // namespace Attributes
 } // namespace SampleMfgSpecificCluster2
 
 } // namespace Clusters