Add command codegen for cluster object (#10171)

* Add codegen for cluster object regarding commands

* run codegen
diff --git a/src/app/tests/TestDataModelSerialization.cpp b/src/app/tests/TestDataModelSerialization.cpp
index cce156f..e890968 100644
--- a/src/app/tests/TestDataModelSerialization.cpp
+++ b/src/app/tests/TestDataModelSerialization.cpp
@@ -515,10 +515,10 @@
         // Encode every field manually except a.
         {
             err = EncodeStruct(_this->mWriter, TLV::AnonymousTag,
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kBFieldId), t.b),
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kCFieldId), t.c),
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kDFieldId), t.d),
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kEFieldId), t.e));
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kB)), t.b),
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kC)), t.c),
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kD)), t.d),
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kE)), t.e));
             NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
         }
 
@@ -585,12 +585,12 @@
         // Encode every field + an extra field.
         {
             err = EncodeStruct(_this->mWriter, TLV::AnonymousTag,
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kAFieldId), t.a),
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kBFieldId), t.b),
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kCFieldId), t.c),
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kDFieldId), t.d),
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kEFieldId), t.e),
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kEFieldId + 1), t.a));
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kA)), t.a),
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kB)), t.b),
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kC)), t.c),
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kD)), t.d),
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kE)), t.e),
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kE) + 1), t.a));
             NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
         }
 
@@ -657,11 +657,11 @@
             // Encode every field manually except a.
             {
                 err = EncodeStruct(_this->mWriter, TLV::AnonymousTag,
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kAFieldId), t.b),
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kBFieldId), t.b),
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kCFieldId), t.c),
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kDFieldId), t.d),
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kEFieldId), t.e));
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kA)), t.b),
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kB)), t.b),
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kC)), t.c),
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kD)), t.d),
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kE)), t.e));
                 NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
             }
 
@@ -708,11 +708,11 @@
             // Encode every field manually except a.
             {
                 err = EncodeStruct(_this->mWriter, TLV::AnonymousTag,
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kAFieldId), t.a),
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kBFieldId), t.b),
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kCFieldId), t.c),
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kDFieldId), t.e),
-                                   MakeTagValuePair(TLV::ContextTag(TestCluster::SimpleStruct::kEFieldId), t.e));
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kA)), t.a),
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kB)), t.b),
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kC)), t.c),
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kD)), t.e),
+                                   MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::SimpleStruct::Fields::kE)), t.e));
                 NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
             }
 
@@ -756,7 +756,7 @@
         // Encode a list of integers for field d instead of a list of structs.
         {
             err = EncodeStruct(_this->mWriter, TLV::AnonymousTag,
-                               MakeTagValuePair(TLV::ContextTag(TestCluster::NestedStructList::kDFieldId), t.e));
+                               MakeTagValuePair(TLV::ContextTag(to_underlying(TestCluster::NestedStructList::Fields::kD)), t.e));
             NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
         }
 
diff --git a/src/app/zap-templates/templates/app/cluster-objects-src.zapt b/src/app/zap-templates/templates/app/cluster-objects-src.zapt
index 86723c8..2480c2e 100644
--- a/src/app/zap-templates/templates/app/cluster-objects-src.zapt
+++ b/src/app/zap-templates/templates/app/cluster-objects-src.zapt
@@ -15,22 +15,24 @@
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
     {{#zcl_struct_items}}
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(k{{asUpperCamelCase label}}FieldId), {{asLowerCamelCase label}}));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::k{{asUpperCamelCase label}})), {{asLowerCamelCase label}}));
     {{/zcl_struct_items}}
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader &reader) {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR) {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
             {{#zcl_struct_items}}
-            case k{{asUpperCamelCase label}}FieldId:
+            case to_underlying(Fields::k{{asUpperCamelCase label}}):
                 ReturnErrorOnFailure(DataModel::Decode(reader, {{asLowerCamelCase label}}));
                 break;
             {{/zcl_struct_items}}
@@ -38,6 +40,7 @@
                 break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -45,8 +48,48 @@
 
 } // namespace {{asType label}}
 {{/zcl_structs}}
-} // namespace {{asUpperCamelCase name}}
 
+namespace Commands {
+{{#zcl_commands}}
+namespace {{asUpperCamelCase name}} {
+CHIP_ERROR Type::Encode(TLV::TLVWriter &writer, uint64_t tag) const{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    {{#zcl_command_arguments}}
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::k{{asUpperCamelCase label}})), {{asLowerCamelCase label}}));
+    {{/zcl_command_arguments}}
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader &reader) {
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR) {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+            {{#zcl_command_arguments}}
+            case to_underlying(Fields::k{{asUpperCamelCase label}}):
+                ReturnErrorOnFailure(DataModel::Decode(reader, {{asLowerCamelCase label}}));
+                break;
+                {{/zcl_command_arguments}}
+            default:
+                break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace {{asUpperCamelCase name}}.
+{{/zcl_commands}}
+} // namespace Commands
+} // namespace {{asUpperCamelCase name}}
 {{/zcl_clusters}}
 
 } // namespace Clusters
diff --git a/src/app/zap-templates/templates/app/cluster-objects.zapt b/src/app/zap-templates/templates/app/cluster-objects.zapt
index e71bd35..4a75082 100644
--- a/src/app/zap-templates/templates/app/cluster-objects.zapt
+++ b/src/app/zap-templates/templates/app/cluster-objects.zapt
@@ -7,6 +7,9 @@
 #include <app/data-model/Encode.h>
 #include <app/data-model/List.h>
 #include <app/util/basic-types.h>
+#include <protocols/interaction_model/Constants.h>
+#include <app-common/zap-generated/ids/Commands.h>
+#include <app-common/zap-generated/ids/Clusters.h>
 
 namespace chip {
 namespace app {
@@ -25,9 +28,9 @@
 
 {{#zcl_structs}}
 namespace {{name}} {
-    enum FieldId {
+    enum class Fields {
     {{#zcl_struct_items}}
-    k{{asUpperCamelCase label}}FieldId = {{index}},
+    k{{asUpperCamelCase label}} = {{index}},
     {{/zcl_struct_items}}
     };
 
@@ -50,7 +53,7 @@
     {{#if struct_contains_array}}
     struct DecodableType {
     public:
-        {{#zcl_struct_items checkForDoubleNestedArray="true"}}
+        {{#zcl_struct_items}}
         {{#if isArray}}
         DataModel::DecodableList<{{#if_is_enum type}}{{type}}{{else}}{{zapTypeToDecodableClusterObjectType type}}{{/if_is_enum}}> {{asLowerCamelCase label}};
         {{else}}
@@ -71,11 +74,45 @@
 namespace Commands {
 {{/first}}
 namespace {{asUpperCamelCase name}} {
-struct Type {};
+enum class Fields {
+    {{#zcl_command_arguments}}
+    k{{asUpperCamelCase label}} = {{index}},
+    {{/zcl_command_arguments}}
+};
 
-struct DecodableType {};
-} // namespace {{asUpperCamelCase name}}
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return {{asUpperCamelCase name}}::Id; }
+    static constexpr ClusterId GetClusterId() { return {{asUpperCamelCase parent.name}}::Id; }
 
+    {{#zcl_command_arguments}}
+    {{#if isArray}}
+    DataModel::List<{{#if_is_enum type}}{{type}}{{else}}{{zapTypeToEncodableClusterObjectType type}}{{/if_is_enum}}> {{asLowerCamelCase label}};
+    {{else}}
+    {{#if_is_enum type}}{{type}}{{else}}{{zapTypeToEncodableClusterObjectType type}}{{/if_is_enum}} {{asLowerCamelCase label}};
+    {{/if}}
+    {{/zcl_command_arguments}}
+
+    CHIP_ERROR Encode(TLV::TLVWriter &writer, uint64_t tag) const;
+};
+
+struct DecodableType {
+public:
+    static constexpr CommandId GetCommandId() { return {{asUpperCamelCase name}}::Id; }
+    static constexpr ClusterId GetClusterId() { return {{asUpperCamelCase parent.name}}::Id; }
+
+    {{#zcl_command_arguments}}
+    {{#if isArray}}
+    DataModel::DecodableList<{{#if_is_enum type}}{{type}}{{else}}{{zapTypeToDecodableClusterObjectType type}}{{/if_is_enum}}> {{asLowerCamelCase label}};
+    {{else}}
+    {{#if_is_enum type}}{{type}}{{else}}{{zapTypeToDecodableClusterObjectType type}}{{/if_is_enum}} {{asLowerCamelCase label}};
+    {{/if}}
+    {{/zcl_command_arguments}}
+    CHIP_ERROR Decode(TLV::TLVReader &reader);
+};
+}; // namespace {{asUpperCamelCase name}}
 {{#last}}
 } // namespace Commands
 {{/last}}
diff --git a/src/app/zap-templates/templates/app/helper.js b/src/app/zap-templates/templates/app/helper.js
index e493079..36e6b3b 100644
--- a/src/app/zap-templates/templates/app/helper.js
+++ b/src/app/zap-templates/templates/app/helper.js
@@ -415,7 +415,7 @@
       case 'uint32_t':
       case 'int64_t':
       case 'uint64_t':
-        return basicType;
+        return zclType;
       default:
         if (isDecodable) {
           return type + '::DecodableType'
diff --git a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml
index 2e7fa01..a6c4dd3 100644
--- a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml
+++ b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml
@@ -29,7 +29,7 @@
     <item name="ValueB" value="0x02"/>
     <item name="ValueC" value="0x03"/>
   </enum>
-  
+
   <struct name="SimpleStruct">
     <cluster code="0x050F"/>
     <item name="a" type="INT8U" optional="false"/>
@@ -111,49 +111,87 @@
     <!-- Test Commands -->
     <command source="client" code="0x00" name="Test" optional="false">
       <description>
-          Simple command without any parameters and without a specific response
+        Simple command without any parameters and without a specific response
       </description>
     </command>
 
     <command source="client" code="0x01" name="TestNotHandled" optional="false">
       <description>
-          Simple command without any parameters and without a specific response not handled by the server
+        Simple command without any parameters and without a specific response not handled by the server
       </description>
     </command>
 
     <command source="client" code="0x02" name="TestSpecific" optional="false">
       <description>
-          Simple command without any parameters and with a specific response
+        Simple command without any parameters and with a specific response
       </description>
     </command>
 
     <command source="client" code="0x03" name="TestUnknownCommand" optional="true">
       <description>
-          Simple command that should not be added to the server.
+        Simple command that should not be added to the server.
       </description>
     </command>
 
     <command source="client" code="0x04" name="TestAddArguments" optional="false">
       <description>
-          Command that takes two arguments and returns their sum.
+        Command that takes two arguments and returns their sum.
       </description>
       <arg name="arg1" type="INT8U"/>
       <arg name="arg2" type="INT8U"/>
     </command>
 
+    <command source="client" code="0x05" name="TestSimpleArgumentRequest" optional="false">
+      <description>
+        Command that takes an argument which is bool
+      </description>
+      <arg name="arg1" type="BOOLEAN"/>
+    </command>
+
+    <command source="client" code="0x06" name="TestStructArrayArgumentRequest" optional="false">
+      <description>
+        Command that takes various arguments that are arrays, including an array of structs which have a list member.
+      </description>
+      <arg name="arg1" type="NestedStructList" array="true"/>
+      <arg name="arg2" type="SimpleStruct" array="true"/>
+      <arg name="arg3" type="SimpleEnum" array="true"/>
+      <arg name="arg4" type="BOOLEAN" array="true"/>
+      <arg name="arg5" type="SimpleEnum"/>
+      <arg name="arg6" type="BOOLEAN"/>
+    </command>
+
     <command source="server" code="0x00" name="TestSpecificResponse" optional="false" disableDefaultResponse="true">
       <description>
-          Simple response for TestWithResponse with a simple return value
+        Simple response for TestWithResponse with a simple return value
       </description>
       <arg name="returnValue" type="INT8U"/>
     </command>
 
     <command source="server" code="0x01" name="TestAddArgumentsResponse" optional="false" disableDefaultResponse="true">
       <description>
-          Response for TestAddArguments that returns the sum.
+        Response for TestAddArguments that returns the sum.
       </description>
       <arg name="returnValue" type="INT8U"/>
     </command>
 
+    <command source="server" code="0x02" name="TestSimpleArgumentResponse" optional="false" disableDefaultResponse="true">
+      <description>
+        Simple response for TestSimpleArgumentRequest with a simple return value
+      </description>
+      <arg name="returnValue" type="BOOLEAN"/>
+    </command>
+
+    <command source="server" code="0x03" name="TestStructArrayArgumentResponse" optional="false" disableDefaultResponse="true">
+      <description>
+        Response for TestStructArrayArgumentRequest with complicated return arguments
+      </description>
+      <arg name="arg1" type="NestedStructList" array="true"/>
+      <arg name="arg2" type="SimpleStruct" array="true"/>
+      <arg name="arg3" type="SimpleEnum" array="true"/>
+      <arg name="arg4" type="BOOLEAN" array="true"/>
+      <arg name="arg5" type="SimpleEnum"/>
+      <arg name="arg6" type="BOOLEAN"/>
+    </command>
+
   </cluster>
 </configurator>
diff --git a/zzz_generated/app-common/app-common/zap-generated/callback.h b/zzz_generated/app-common/app-common/zap-generated/callback.h
index b1a3117..5929b4f 100644
--- a/zzz_generated/app-common/app-common/zap-generated/callback.h
+++ b/zzz_generated/app-common/app-common/zap-generated/callback.h
@@ -17128,18 +17128,44 @@
     chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, chip::EndpointId endpoint,
     chip::app::Clusters::TestCluster::Commands::TestSpecific::DecodableType & fields);
 /**
+ * @brief Test Cluster Cluster TestSimpleArgumentResponse Command callback (from server)
+ */
+bool emberAfTestClusterClusterTestSimpleArgumentResponseCallback(chip::EndpointId endpoint, chip::app::CommandSender * commandObj,
+                                                                 bool returnValue);
+/**
  * @brief Test Cluster Cluster TestUnknownCommand Command callback (from client)
  */
 bool emberAfTestClusterClusterTestUnknownCommandCallback(
     chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, chip::EndpointId endpoint,
     chip::app::Clusters::TestCluster::Commands::TestUnknownCommand::DecodableType & fields);
 /**
+ * @brief Test Cluster Cluster TestStructArrayArgumentResponse Command callback (from server)
+ */
+bool emberAfTestClusterClusterTestStructArrayArgumentResponseCallback(
+    chip::EndpointId endpoint, chip::app::CommandSender * commandObj, /* TYPE WARNING: array array defaults to */ uint8_t * arg1,
+    /* TYPE WARNING: array array defaults to */ uint8_t * arg2, /* TYPE WARNING: array array defaults to */ uint8_t * arg3,
+    /* TYPE WARNING: array array defaults to */ uint8_t * arg4, uint8_t arg5, bool arg6);
+/**
  * @brief Test Cluster Cluster TestAddArguments Command callback (from client)
  */
 bool emberAfTestClusterClusterTestAddArgumentsCallback(
     chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, chip::EndpointId endpoint,
     uint8_t arg1, uint8_t arg2, chip::app::Clusters::TestCluster::Commands::TestAddArguments::DecodableType & fields);
 /**
+ * @brief Test Cluster Cluster TestSimpleArgumentRequest Command callback (from client)
+ */
+bool emberAfTestClusterClusterTestSimpleArgumentRequestCallback(
+    chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, chip::EndpointId endpoint,
+    bool arg1, chip::app::Clusters::TestCluster::Commands::TestSimpleArgumentRequest::DecodableType & fields);
+/**
+ * @brief Test Cluster Cluster TestStructArrayArgumentRequest Command callback (from client)
+ */
+bool emberAfTestClusterClusterTestStructArrayArgumentRequestCallback(
+    chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, chip::EndpointId endpoint,
+    /* TYPE WARNING: array array defaults to */ uint8_t * arg1, /* TYPE WARNING: array array defaults to */ uint8_t * arg2,
+    /* TYPE WARNING: array array defaults to */ uint8_t * arg3, /* TYPE WARNING: array array defaults to */ uint8_t * arg4,
+    uint8_t arg5, bool arg6, chip::app::Clusters::TestCluster::Commands::TestStructArrayArgumentRequest::DecodableType & fields);
+/**
  * @brief Messaging Cluster DisplayMessage Command callback (from server)
  */
 bool emberAfMessagingClusterDisplayMessageCallback(chip::EndpointId endpoint, chip::app::CommandSender * commandObj,
diff --git a/zzz_generated/app-common/app-common/zap-generated/client-command-macro.h b/zzz_generated/app-common/app-common/zap-generated/client-command-macro.h
index b864e66..e2a8367 100644
--- a/zzz_generated/app-common/app-common/zap-generated/client-command-macro.h
+++ b/zzz_generated/app-common/app-common/zap-generated/client-command-macro.h
@@ -4697,6 +4697,17 @@
                                                                                                                                    \
                                                            ZCL_TEST_SPECIFIC_COMMAND_ID, "", );
 
+/** @brief Command description for TestSimpleArgumentResponse
+ *
+ * Command: TestSimpleArgumentResponse
+ * @param returnValue BOOLEAN
+ */
+#define emberAfFillCommandTest                                                                                                     \
+    ClusterClusterTestSimpleArgumentResponse(returnValue)                                                                          \
+        emberAfFillExternalBuffer(mask,                                                                                            \
+                                                                                                                                   \
+                                  ZCL_TEST_SIMPLE_ARGUMENT_RESPONSE_COMMAND_ID, "u", returnValue);
+
 /** @brief Command description for TestUnknownCommand
  *
  * Command: TestUnknownCommand
@@ -4706,6 +4717,27 @@
                                                                                                                                    \
                                                                  ZCL_TEST_UNKNOWN_COMMAND_COMMAND_ID, "", );
 
+/** @brief Command description for TestStructArrayArgumentResponse
+ *
+ * Command: TestStructArrayArgumentResponse
+ * @param arg1 NestedStructList []
+ * @param arg1Len int
+ * @param arg2 SimpleStruct []
+ * @param arg2Len int
+ * @param arg3 SimpleEnum []
+ * @param arg3Len int
+ * @param arg4 BOOLEAN []
+ * @param arg4Len int
+ * @param arg5 SimpleEnum
+ * @param arg6 BOOLEAN
+ */
+#define emberAfFillCommandTest                                                                                                     \
+    ClusterClusterTestStructArrayArgumentResponse(arg1, arg1Len, arg2, arg2Len, arg3, arg3Len, arg4, arg4Len, arg5, arg6)          \
+        emberAfFillExternalBuffer(mask,                                                                                            \
+                                                                                                                                   \
+                                  ZCL_TEST_STRUCT_ARRAY_ARGUMENT_RESPONSE_COMMAND_ID, "bbbbuu", arg1, arg1Len, arg2, arg2Len,      \
+                                  arg3, arg3Len, arg4, arg4Len, arg5, arg6);
+
 /** @brief Command description for TestAddArguments
  *
  * Command: TestAddArguments
@@ -4717,6 +4749,38 @@
                                                                                                                                    \
                                                                          ZCL_TEST_ADD_ARGUMENTS_COMMAND_ID, "uu", arg1, arg2);
 
+/** @brief Command description for TestSimpleArgumentRequest
+ *
+ * Command: TestSimpleArgumentRequest
+ * @param arg1 BOOLEAN
+ */
+#define emberAfFillCommandTest                                                                                                     \
+    ClusterClusterTestSimpleArgumentRequest(arg1)                                                                                  \
+        emberAfFillExternalBuffer(mask,                                                                                            \
+                                                                                                                                   \
+                                  ZCL_TEST_SIMPLE_ARGUMENT_REQUEST_COMMAND_ID, "u", arg1);
+
+/** @brief Command description for TestStructArrayArgumentRequest
+ *
+ * Command: TestStructArrayArgumentRequest
+ * @param arg1 NestedStructList []
+ * @param arg1Len int
+ * @param arg2 SimpleStruct []
+ * @param arg2Len int
+ * @param arg3 SimpleEnum []
+ * @param arg3Len int
+ * @param arg4 BOOLEAN []
+ * @param arg4Len int
+ * @param arg5 SimpleEnum
+ * @param arg6 BOOLEAN
+ */
+#define emberAfFillCommandTest                                                                                                     \
+    ClusterClusterTestStructArrayArgumentRequest(arg1, arg1Len, arg2, arg2Len, arg3, arg3Len, arg4, arg4Len, arg5, arg6)           \
+        emberAfFillExternalBuffer(mask,                                                                                            \
+                                                                                                                                   \
+                                  ZCL_TEST_STRUCT_ARRAY_ARGUMENT_REQUEST_COMMAND_ID, "bbbbuu", arg1, arg1Len, arg2, arg2Len, arg3, \
+                                  arg3Len, arg4, arg4Len, arg5, arg6);
+
 /** @brief Command description for GetLastMessage
  *
  * Command: GetLastMessage
diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
index 873e73f..903113d 100644
--- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
+++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
@@ -25,119 +25,2426 @@
 namespace app {
 namespace Clusters {
 namespace PowerConfiguration {
+
+namespace Commands {
+} // namespace Commands
 } // namespace PowerConfiguration
-
 namespace DeviceTemperatureConfiguration {
+
+namespace Commands {
+} // namespace Commands
 } // namespace DeviceTemperatureConfiguration
-
 namespace Identify {
+
+namespace Commands {
+namespace Identify {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIdentifyTime)), identifyTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kIdentifyTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, identifyTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Identify.
+namespace IdentifyQueryResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeout)), timeout));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTimeout):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeout));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace IdentifyQueryResponse.
+namespace IdentifyQuery {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace IdentifyQuery.
+namespace TriggerEffect {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEffectIdentifier)), effectIdentifier));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEffectVariant)), effectVariant));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kEffectIdentifier):
+            ReturnErrorOnFailure(DataModel::Decode(reader, effectIdentifier));
+            break;
+        case to_underlying(Fields::kEffectVariant):
+            ReturnErrorOnFailure(DataModel::Decode(reader, effectVariant));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TriggerEffect.
+} // namespace Commands
 } // namespace Identify
-
 namespace Groups {
-} // namespace Groups
 
+namespace Commands {
+namespace AddGroup {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupName)), groupName));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kGroupName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupName));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddGroup.
+namespace AddGroupResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddGroupResponse.
+namespace ViewGroup {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ViewGroup.
+namespace ViewGroupResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupName)), groupName));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kGroupName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupName));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ViewGroupResponse.
+namespace GetGroupMembership {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupCount)), groupCount));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupList)), groupList));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupCount));
+            break;
+        case to_underlying(Fields::kGroupList):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupList));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetGroupMembership.
+namespace GetGroupMembershipResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCapacity)), capacity));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupCount)), groupCount));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupList)), groupList));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCapacity):
+            ReturnErrorOnFailure(DataModel::Decode(reader, capacity));
+            break;
+        case to_underlying(Fields::kGroupCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupCount));
+            break;
+        case to_underlying(Fields::kGroupList):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupList));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetGroupMembershipResponse.
+namespace RemoveGroup {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveGroup.
+namespace RemoveGroupResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveGroupResponse.
+namespace RemoveAllGroups {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveAllGroups.
+namespace AddGroupIfIdentifying {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupName)), groupName));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kGroupName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupName));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddGroupIfIdentifying.
+} // namespace Commands
+} // namespace Groups
 namespace Scenes {
 namespace SceneExtensionFieldSet {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kClusterIdFieldId), clusterId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLengthFieldId), length));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kValueFieldId), value));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kClusterId)), clusterId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLength)), length));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kValue)), value));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kClusterIdFieldId:
+        case to_underlying(Fields::kClusterId):
             ReturnErrorOnFailure(DataModel::Decode(reader, clusterId));
             break;
-        case kLengthFieldId:
+        case to_underlying(Fields::kLength):
             ReturnErrorOnFailure(DataModel::Decode(reader, length));
             break;
-        case kValueFieldId:
+        case to_underlying(Fields::kValue):
             ReturnErrorOnFailure(DataModel::Decode(reader, value));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace SceneExtensionFieldSet
-} // namespace Scenes
 
-namespace OnOff {
-} // namespace OnOff
-
-namespace OnOffSwitchConfiguration {
-} // namespace OnOffSwitchConfiguration
-
-namespace LevelControl {
-} // namespace LevelControl
-
-namespace Alarms {
-} // namespace Alarms
-
-namespace Time {
-} // namespace Time
-
-namespace BinaryInputBasic {
-} // namespace BinaryInputBasic
-
-namespace PowerProfile {
-namespace PowerProfileRecord {
+namespace Commands {
+namespace AddScene {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPowerProfileIdFieldId), powerProfileId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEnergyPhaseIdFieldId), energyPhaseId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPowerProfileRemoteControlFieldId), powerProfileRemoteControl));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPowerProfileStateFieldId), powerProfileState));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneName)), sceneName));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExtensionFieldSets)), extensionFieldSets));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kPowerProfileIdFieldId:
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kSceneName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneName));
+            break;
+        case to_underlying(Fields::kExtensionFieldSets):
+            ReturnErrorOnFailure(DataModel::Decode(reader, extensionFieldSets));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddScene.
+namespace AddSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddSceneResponse.
+namespace ViewScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ViewScene.
+namespace ViewSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneName)), sceneName));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExtensionFieldSets)), extensionFieldSets));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kSceneName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneName));
+            break;
+        case to_underlying(Fields::kExtensionFieldSets):
+            ReturnErrorOnFailure(DataModel::Decode(reader, extensionFieldSets));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ViewSceneResponse.
+namespace RemoveScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveScene.
+namespace RemoveSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveSceneResponse.
+namespace RemoveAllScenes {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveAllScenes.
+namespace RemoveAllScenesResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveAllScenesResponse.
+namespace StoreScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StoreScene.
+namespace StoreSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StoreSceneResponse.
+namespace RecallScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RecallScene.
+namespace GetSceneMembership {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetSceneMembership.
+namespace GetSceneMembershipResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCapacity)), capacity));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneCount)), sceneCount));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneList)), sceneList));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kCapacity):
+            ReturnErrorOnFailure(DataModel::Decode(reader, capacity));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneCount));
+            break;
+        case to_underlying(Fields::kSceneList):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneList));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetSceneMembershipResponse.
+namespace EnhancedAddScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneName)), sceneName));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExtensionFieldSets)), extensionFieldSets));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kSceneName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneName));
+            break;
+        case to_underlying(Fields::kExtensionFieldSets):
+            ReturnErrorOnFailure(DataModel::Decode(reader, extensionFieldSets));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnhancedAddScene.
+namespace EnhancedAddSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnhancedAddSceneResponse.
+namespace EnhancedViewScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnhancedViewScene.
+namespace EnhancedViewSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneId)), sceneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneName)), sceneName));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExtensionFieldSets)), extensionFieldSets));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kSceneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneId));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kSceneName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneName));
+            break;
+        case to_underlying(Fields::kExtensionFieldSets):
+            ReturnErrorOnFailure(DataModel::Decode(reader, extensionFieldSets));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnhancedViewSceneResponse.
+namespace CopyScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMode)), mode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupIdFrom)), groupIdFrom));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneIdFrom)), sceneIdFrom));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupIdTo)), groupIdTo));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneIdTo)), sceneIdTo));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mode));
+            break;
+        case to_underlying(Fields::kGroupIdFrom):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupIdFrom));
+            break;
+        case to_underlying(Fields::kSceneIdFrom):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneIdFrom));
+            break;
+        case to_underlying(Fields::kGroupIdTo):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupIdTo));
+            break;
+        case to_underlying(Fields::kSceneIdTo):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneIdTo));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CopyScene.
+namespace CopySceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupIdFrom)), groupIdFrom));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSceneIdFrom)), sceneIdFrom));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kGroupIdFrom):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupIdFrom));
+            break;
+        case to_underlying(Fields::kSceneIdFrom):
+            ReturnErrorOnFailure(DataModel::Decode(reader, sceneIdFrom));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CopySceneResponse.
+} // namespace Commands
+} // namespace Scenes
+namespace OnOff {
+
+namespace Commands {
+namespace Off {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Off.
+namespace SampleMfgSpecificOffWithTransition {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SampleMfgSpecificOffWithTransition.
+namespace On {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace On.
+namespace SampleMfgSpecificOnWithTransition {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SampleMfgSpecificOnWithTransition.
+namespace SampleMfgSpecificOnWithTransition2 {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SampleMfgSpecificOnWithTransition2.
+namespace Toggle {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Toggle.
+namespace SampleMfgSpecificToggleWithTransition {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SampleMfgSpecificToggleWithTransition.
+namespace SampleMfgSpecificToggleWithTransition2 {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SampleMfgSpecificToggleWithTransition2.
+namespace OffWithEffect {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEffectId)), effectId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEffectVariant)), effectVariant));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kEffectId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, effectId));
+            break;
+        case to_underlying(Fields::kEffectVariant):
+            ReturnErrorOnFailure(DataModel::Decode(reader, effectVariant));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OffWithEffect.
+namespace OnWithRecallGlobalScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OnWithRecallGlobalScene.
+namespace OnWithTimedOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOnOffControl)), onOffControl));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOnTime)), onTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOffWaitTime)), offWaitTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kOnOffControl):
+            ReturnErrorOnFailure(DataModel::Decode(reader, onOffControl));
+            break;
+        case to_underlying(Fields::kOnTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, onTime));
+            break;
+        case to_underlying(Fields::kOffWaitTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, offWaitTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OnWithTimedOff.
+} // namespace Commands
+} // namespace OnOff
+namespace OnOffSwitchConfiguration {
+
+namespace Commands {
+} // namespace Commands
+} // namespace OnOffSwitchConfiguration
+namespace LevelControl {
+
+namespace Commands {
+namespace MoveToLevel {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLevel)), level));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionMask)), optionMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionOverride)), optionOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLevel):
+            ReturnErrorOnFailure(DataModel::Decode(reader, level));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionMask));
+            break;
+        case to_underlying(Fields::kOptionOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveToLevel.
+namespace Move {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMoveMode)), moveMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRate)), rate));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionMask)), optionMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionOverride)), optionOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMoveMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, moveMode));
+            break;
+        case to_underlying(Fields::kRate):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rate));
+            break;
+        case to_underlying(Fields::kOptionMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionMask));
+            break;
+        case to_underlying(Fields::kOptionOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Move.
+namespace Step {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepMode)), stepMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepSize)), stepSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionMask)), optionMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionOverride)), optionOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStepMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepMode));
+            break;
+        case to_underlying(Fields::kStepSize):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepSize));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionMask));
+            break;
+        case to_underlying(Fields::kOptionOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Step.
+namespace Stop {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionMask)), optionMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionOverride)), optionOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kOptionMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionMask));
+            break;
+        case to_underlying(Fields::kOptionOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Stop.
+namespace MoveToLevelWithOnOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLevel)), level));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLevel):
+            ReturnErrorOnFailure(DataModel::Decode(reader, level));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveToLevelWithOnOff.
+namespace MoveWithOnOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMoveMode)), moveMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRate)), rate));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMoveMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, moveMode));
+            break;
+        case to_underlying(Fields::kRate):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rate));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveWithOnOff.
+namespace StepWithOnOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepMode)), stepMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepSize)), stepSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStepMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepMode));
+            break;
+        case to_underlying(Fields::kStepSize):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepSize));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StepWithOnOff.
+namespace StopWithOnOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StopWithOnOff.
+} // namespace Commands
+} // namespace LevelControl
+namespace Alarms {
+
+namespace Commands {
+namespace ResetAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAlarmCode)), alarmCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kClusterId)), clusterId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAlarmCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, alarmCode));
+            break;
+        case to_underlying(Fields::kClusterId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, clusterId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ResetAlarm.
+namespace Alarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAlarmCode)), alarmCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kClusterId)), clusterId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAlarmCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, alarmCode));
+            break;
+        case to_underlying(Fields::kClusterId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, clusterId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Alarm.
+namespace ResetAllAlarms {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ResetAllAlarms.
+namespace GetAlarmResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAlarmCode)), alarmCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kClusterId)), clusterId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeStamp)), timeStamp));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kAlarmCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, alarmCode));
+            break;
+        case to_underlying(Fields::kClusterId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, clusterId));
+            break;
+        case to_underlying(Fields::kTimeStamp):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeStamp));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetAlarmResponse.
+namespace GetAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetAlarm.
+namespace ResetAlarmLog {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ResetAlarmLog.
+} // namespace Commands
+} // namespace Alarms
+namespace Time {
+
+namespace Commands {
+} // namespace Commands
+} // namespace Time
+namespace BinaryInputBasic {
+
+namespace Commands {
+} // namespace Commands
+} // namespace BinaryInputBasic
+namespace PowerProfile {
+namespace PowerProfileRecord {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEnergyPhaseId)), energyPhaseId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileRemoteControl)), powerProfileRemoteControl));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileState)), powerProfileState));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
             ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
             break;
-        case kEnergyPhaseIdFieldId:
+        case to_underlying(Fields::kEnergyPhaseId):
             ReturnErrorOnFailure(DataModel::Decode(reader, energyPhaseId));
             break;
-        case kPowerProfileRemoteControlFieldId:
+        case to_underlying(Fields::kPowerProfileRemoteControl):
             ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileRemoteControl));
             break;
-        case kPowerProfileStateFieldId:
+        case to_underlying(Fields::kPowerProfileState):
             ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileState));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -149,32 +2456,35 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEnergyPhaseIdFieldId), energyPhaseId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduledTimeFieldId), scheduledTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEnergyPhaseId)), energyPhaseId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduledTime)), scheduledTime));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kEnergyPhaseIdFieldId:
+        case to_underlying(Fields::kEnergyPhaseId):
             ReturnErrorOnFailure(DataModel::Decode(reader, energyPhaseId));
             break;
-        case kScheduledTimeFieldId:
+        case to_underlying(Fields::kScheduledTime):
             ReturnErrorOnFailure(DataModel::Decode(reader, scheduledTime));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -186,178 +2496,2195 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEnergyPhaseIdFieldId), energyPhaseId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMacroPhaseIdFieldId), macroPhaseId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kExpectedDurationFieldId), expectedDuration));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPeakPowerFieldId), peakPower));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEnergyFieldId), energy));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMaxActivationDelayFieldId), maxActivationDelay));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEnergyPhaseId)), energyPhaseId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMacroPhaseId)), macroPhaseId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExpectedDuration)), expectedDuration));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPeakPower)), peakPower));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEnergy)), energy));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMaxActivationDelay)), maxActivationDelay));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kEnergyPhaseIdFieldId:
+        case to_underlying(Fields::kEnergyPhaseId):
             ReturnErrorOnFailure(DataModel::Decode(reader, energyPhaseId));
             break;
-        case kMacroPhaseIdFieldId:
+        case to_underlying(Fields::kMacroPhaseId):
             ReturnErrorOnFailure(DataModel::Decode(reader, macroPhaseId));
             break;
-        case kExpectedDurationFieldId:
+        case to_underlying(Fields::kExpectedDuration):
             ReturnErrorOnFailure(DataModel::Decode(reader, expectedDuration));
             break;
-        case kPeakPowerFieldId:
+        case to_underlying(Fields::kPeakPower):
             ReturnErrorOnFailure(DataModel::Decode(reader, peakPower));
             break;
-        case kEnergyFieldId:
+        case to_underlying(Fields::kEnergy):
             ReturnErrorOnFailure(DataModel::Decode(reader, energy));
             break;
-        case kMaxActivationDelayFieldId:
+        case to_underlying(Fields::kMaxActivationDelay):
             ReturnErrorOnFailure(DataModel::Decode(reader, maxActivationDelay));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace TransferredPhase
+
+namespace Commands {
+namespace PowerProfileRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfileRequest.
+namespace PowerProfileNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTotalProfileNum)), totalProfileNum));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumOfTransferredPhases)), numOfTransferredPhases));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransferredPhases)), transferredPhases));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTotalProfileNum):
+            ReturnErrorOnFailure(DataModel::Decode(reader, totalProfileNum));
+            break;
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kNumOfTransferredPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numOfTransferredPhases));
+            break;
+        case to_underlying(Fields::kTransferredPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transferredPhases));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfileNotification.
+namespace PowerProfileStateRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfileStateRequest.
+namespace PowerProfileResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTotalProfileNum)), totalProfileNum));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumOfTransferredPhases)), numOfTransferredPhases));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransferredPhases)), transferredPhases));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTotalProfileNum):
+            ReturnErrorOnFailure(DataModel::Decode(reader, totalProfileNum));
+            break;
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kNumOfTransferredPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numOfTransferredPhases));
+            break;
+        case to_underlying(Fields::kTransferredPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transferredPhases));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfileResponse.
+namespace GetPowerProfilePriceResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCurrency)), currency));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPrice)), price));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPriceTrailingDigit)), priceTrailingDigit));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kCurrency):
+            ReturnErrorOnFailure(DataModel::Decode(reader, currency));
+            break;
+        case to_underlying(Fields::kPrice):
+            ReturnErrorOnFailure(DataModel::Decode(reader, price));
+            break;
+        case to_underlying(Fields::kPriceTrailingDigit):
+            ReturnErrorOnFailure(DataModel::Decode(reader, priceTrailingDigit));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetPowerProfilePriceResponse.
+namespace PowerProfileStateResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileCount)), powerProfileCount));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileRecords)), powerProfileRecords));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileCount));
+            break;
+        case to_underlying(Fields::kPowerProfileRecords):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileRecords));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfileStateResponse.
+namespace GetOverallSchedulePriceResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCurrency)), currency));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPrice)), price));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPriceTrailingDigit)), priceTrailingDigit));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCurrency):
+            ReturnErrorOnFailure(DataModel::Decode(reader, currency));
+            break;
+        case to_underlying(Fields::kPrice):
+            ReturnErrorOnFailure(DataModel::Decode(reader, price));
+            break;
+        case to_underlying(Fields::kPriceTrailingDigit):
+            ReturnErrorOnFailure(DataModel::Decode(reader, priceTrailingDigit));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetOverallSchedulePriceResponse.
+namespace GetPowerProfilePrice {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetPowerProfilePrice.
+namespace EnergyPhasesScheduleNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumOfScheduledPhases)), numOfScheduledPhases));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduledPhases)), scheduledPhases));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kNumOfScheduledPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numOfScheduledPhases));
+            break;
+        case to_underlying(Fields::kScheduledPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduledPhases));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnergyPhasesScheduleNotification.
+namespace PowerProfilesStateNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileCount)), powerProfileCount));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileRecords)), powerProfileRecords));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileCount));
+            break;
+        case to_underlying(Fields::kPowerProfileRecords):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileRecords));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfilesStateNotification.
+namespace EnergyPhasesScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumOfScheduledPhases)), numOfScheduledPhases));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduledPhases)), scheduledPhases));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kNumOfScheduledPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numOfScheduledPhases));
+            break;
+        case to_underlying(Fields::kScheduledPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduledPhases));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnergyPhasesScheduleResponse.
+namespace GetOverallSchedulePrice {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetOverallSchedulePrice.
+namespace PowerProfileScheduleConstraintsRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfileScheduleConstraintsRequest.
+namespace EnergyPhasesScheduleRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnergyPhasesScheduleRequest.
+namespace EnergyPhasesScheduleStateRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnergyPhasesScheduleStateRequest.
+namespace EnergyPhasesScheduleStateResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumOfScheduledPhases)), numOfScheduledPhases));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduledPhases)), scheduledPhases));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kNumOfScheduledPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numOfScheduledPhases));
+            break;
+        case to_underlying(Fields::kScheduledPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduledPhases));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnergyPhasesScheduleStateResponse.
+namespace GetPowerProfilePriceExtendedResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCurrency)), currency));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPrice)), price));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPriceTrailingDigit)), priceTrailingDigit));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kCurrency):
+            ReturnErrorOnFailure(DataModel::Decode(reader, currency));
+            break;
+        case to_underlying(Fields::kPrice):
+            ReturnErrorOnFailure(DataModel::Decode(reader, price));
+            break;
+        case to_underlying(Fields::kPriceTrailingDigit):
+            ReturnErrorOnFailure(DataModel::Decode(reader, priceTrailingDigit));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetPowerProfilePriceExtendedResponse.
+namespace EnergyPhasesScheduleStateNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumOfScheduledPhases)), numOfScheduledPhases));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduledPhases)), scheduledPhases));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kNumOfScheduledPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numOfScheduledPhases));
+            break;
+        case to_underlying(Fields::kScheduledPhases):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduledPhases));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnergyPhasesScheduleStateNotification.
+namespace PowerProfileScheduleConstraintsNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartAfter)), startAfter));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStopBefore)), stopBefore));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kStartAfter):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startAfter));
+            break;
+        case to_underlying(Fields::kStopBefore):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stopBefore));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfileScheduleConstraintsNotification.
+namespace PowerProfileScheduleConstraintsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartAfter)), startAfter));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStopBefore)), stopBefore));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kStartAfter):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startAfter));
+            break;
+        case to_underlying(Fields::kStopBefore):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stopBefore));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PowerProfileScheduleConstraintsResponse.
+namespace GetPowerProfilePriceExtended {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptions)), options));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileId)), powerProfileId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPowerProfileStartTime)), powerProfileStartTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kOptions):
+            ReturnErrorOnFailure(DataModel::Decode(reader, options));
+            break;
+        case to_underlying(Fields::kPowerProfileId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileId));
+            break;
+        case to_underlying(Fields::kPowerProfileStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, powerProfileStartTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetPowerProfilePriceExtended.
+} // namespace Commands
 } // namespace PowerProfile
-
 namespace ApplianceControl {
-} // namespace ApplianceControl
 
+namespace Commands {
+namespace ExecutionOfACommand {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCommandId)), commandId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCommandId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, commandId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ExecutionOfACommand.
+namespace SignalStateResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kApplianceStatus)), applianceStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRemoteEnableFlagsAndDeviceStatus2)),
+                                           remoteEnableFlagsAndDeviceStatus2));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kApplianceStatus2)), applianceStatus2));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kApplianceStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, applianceStatus));
+            break;
+        case to_underlying(Fields::kRemoteEnableFlagsAndDeviceStatus2):
+            ReturnErrorOnFailure(DataModel::Decode(reader, remoteEnableFlagsAndDeviceStatus2));
+            break;
+        case to_underlying(Fields::kApplianceStatus2):
+            ReturnErrorOnFailure(DataModel::Decode(reader, applianceStatus2));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SignalStateResponse.
+namespace SignalState {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SignalState.
+namespace SignalStateNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kApplianceStatus)), applianceStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRemoteEnableFlagsAndDeviceStatus2)),
+                                           remoteEnableFlagsAndDeviceStatus2));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kApplianceStatus2)), applianceStatus2));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kApplianceStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, applianceStatus));
+            break;
+        case to_underlying(Fields::kRemoteEnableFlagsAndDeviceStatus2):
+            ReturnErrorOnFailure(DataModel::Decode(reader, remoteEnableFlagsAndDeviceStatus2));
+            break;
+        case to_underlying(Fields::kApplianceStatus2):
+            ReturnErrorOnFailure(DataModel::Decode(reader, applianceStatus2));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SignalStateNotification.
+namespace WriteFunctions {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFunctionId)), functionId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFunctionDataType)), functionDataType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFunctionData)), functionData));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kFunctionId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, functionId));
+            break;
+        case to_underlying(Fields::kFunctionDataType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, functionDataType));
+            break;
+        case to_underlying(Fields::kFunctionData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, functionData));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace WriteFunctions.
+namespace OverloadPauseResume {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OverloadPauseResume.
+namespace OverloadPause {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OverloadPause.
+namespace OverloadWarning {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kWarningEvent)), warningEvent));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kWarningEvent):
+            ReturnErrorOnFailure(DataModel::Decode(reader, warningEvent));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OverloadWarning.
+} // namespace Commands
+} // namespace ApplianceControl
 namespace Descriptor {
 namespace DeviceType {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTypeFieldId), type));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRevisionFieldId), revision));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kType)), type));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRevision)), revision));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kTypeFieldId:
+        case to_underlying(Fields::kType):
             ReturnErrorOnFailure(DataModel::Decode(reader, type));
             break;
-        case kRevisionFieldId:
+        case to_underlying(Fields::kRevision):
             ReturnErrorOnFailure(DataModel::Decode(reader, revision));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace DeviceType
+
+namespace Commands {
+} // namespace Commands
 } // namespace Descriptor
-
 namespace PollControl {
+
+namespace Commands {
+namespace CheckIn {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CheckIn.
+namespace CheckInResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartFastPolling)), startFastPolling));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFastPollTimeout)), fastPollTimeout));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStartFastPolling):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startFastPolling));
+            break;
+        case to_underlying(Fields::kFastPollTimeout):
+            ReturnErrorOnFailure(DataModel::Decode(reader, fastPollTimeout));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CheckInResponse.
+namespace FastPollStop {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace FastPollStop.
+namespace SetLongPollInterval {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNewLongPollInterval)), newLongPollInterval));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNewLongPollInterval):
+            ReturnErrorOnFailure(DataModel::Decode(reader, newLongPollInterval));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetLongPollInterval.
+namespace SetShortPollInterval {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNewShortPollInterval)), newShortPollInterval));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNewShortPollInterval):
+            ReturnErrorOnFailure(DataModel::Decode(reader, newShortPollInterval));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetShortPollInterval.
+} // namespace Commands
 } // namespace PollControl
-
 namespace Basic {
+
+namespace Commands {
+namespace StartUp {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StartUp.
+namespace MfgSpecificPing {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MfgSpecificPing.
+namespace ShutDown {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ShutDown.
+namespace Leave {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Leave.
+} // namespace Commands
 } // namespace Basic
-
 namespace OtaSoftwareUpdateProvider {
+
+namespace Commands {
+namespace QueryImage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kVendorId)), vendorId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kProductId)), productId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kHardwareVersion)), hardwareVersion));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSoftwareVersion)), softwareVersion));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kProtocolsSupported)), protocolsSupported));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocation)), location));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRequestorCanConsent)), requestorCanConsent));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMetadataForProvider)), metadataForProvider));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kVendorId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, vendorId));
+            break;
+        case to_underlying(Fields::kProductId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, productId));
+            break;
+        case to_underlying(Fields::kHardwareVersion):
+            ReturnErrorOnFailure(DataModel::Decode(reader, hardwareVersion));
+            break;
+        case to_underlying(Fields::kSoftwareVersion):
+            ReturnErrorOnFailure(DataModel::Decode(reader, softwareVersion));
+            break;
+        case to_underlying(Fields::kProtocolsSupported):
+            ReturnErrorOnFailure(DataModel::Decode(reader, protocolsSupported));
+            break;
+        case to_underlying(Fields::kLocation):
+            ReturnErrorOnFailure(DataModel::Decode(reader, location));
+            break;
+        case to_underlying(Fields::kRequestorCanConsent):
+            ReturnErrorOnFailure(DataModel::Decode(reader, requestorCanConsent));
+            break;
+        case to_underlying(Fields::kMetadataForProvider):
+            ReturnErrorOnFailure(DataModel::Decode(reader, metadataForProvider));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace QueryImage.
+namespace ApplyUpdateRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUpdateToken)), updateToken));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNewVersion)), newVersion));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUpdateToken):
+            ReturnErrorOnFailure(DataModel::Decode(reader, updateToken));
+            break;
+        case to_underlying(Fields::kNewVersion):
+            ReturnErrorOnFailure(DataModel::Decode(reader, newVersion));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ApplyUpdateRequest.
+namespace NotifyUpdateApplied {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUpdateToken)), updateToken));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSoftwareVersion)), softwareVersion));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUpdateToken):
+            ReturnErrorOnFailure(DataModel::Decode(reader, updateToken));
+            break;
+        case to_underlying(Fields::kSoftwareVersion):
+            ReturnErrorOnFailure(DataModel::Decode(reader, softwareVersion));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace NotifyUpdateApplied.
+namespace QueryImageResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDelayedActionTime)), delayedActionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kImageURI)), imageURI));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSoftwareVersion)), softwareVersion));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSoftwareVersionString)), softwareVersionString));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUpdateToken)), updateToken));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserConsentNeeded)), userConsentNeeded));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMetadataForRequestor)), metadataForRequestor));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kDelayedActionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, delayedActionTime));
+            break;
+        case to_underlying(Fields::kImageURI):
+            ReturnErrorOnFailure(DataModel::Decode(reader, imageURI));
+            break;
+        case to_underlying(Fields::kSoftwareVersion):
+            ReturnErrorOnFailure(DataModel::Decode(reader, softwareVersion));
+            break;
+        case to_underlying(Fields::kSoftwareVersionString):
+            ReturnErrorOnFailure(DataModel::Decode(reader, softwareVersionString));
+            break;
+        case to_underlying(Fields::kUpdateToken):
+            ReturnErrorOnFailure(DataModel::Decode(reader, updateToken));
+            break;
+        case to_underlying(Fields::kUserConsentNeeded):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userConsentNeeded));
+            break;
+        case to_underlying(Fields::kMetadataForRequestor):
+            ReturnErrorOnFailure(DataModel::Decode(reader, metadataForRequestor));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace QueryImageResponse.
+namespace ApplyUpdateRequestResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAction)), action));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDelayedActionTime)), delayedActionTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAction):
+            ReturnErrorOnFailure(DataModel::Decode(reader, action));
+            break;
+        case to_underlying(Fields::kDelayedActionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, delayedActionTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ApplyUpdateRequestResponse.
+} // namespace Commands
 } // namespace OtaSoftwareUpdateProvider
-
 namespace OtaSoftwareUpdateRequestor {
+
+namespace Commands {
+namespace AnnounceOtaProvider {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kProviderLocation)), providerLocation));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kVendorId)), vendorId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAnnouncementReason)), announcementReason));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMetadataForNode)), metadataForNode));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kProviderLocation):
+            ReturnErrorOnFailure(DataModel::Decode(reader, providerLocation));
+            break;
+        case to_underlying(Fields::kVendorId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, vendorId));
+            break;
+        case to_underlying(Fields::kAnnouncementReason):
+            ReturnErrorOnFailure(DataModel::Decode(reader, announcementReason));
+            break;
+        case to_underlying(Fields::kMetadataForNode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, metadataForNode));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AnnounceOtaProvider.
+} // namespace Commands
 } // namespace OtaSoftwareUpdateRequestor
-
 namespace PowerSource {
-} // namespace PowerSource
 
+namespace Commands {
+} // namespace Commands
+} // namespace PowerSource
 namespace GeneralCommissioning {
 namespace BasicCommissioningInfoType {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFailSafeExpiryLengthMsFieldId), failSafeExpiryLengthMs));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFailSafeExpiryLengthMs)), failSafeExpiryLengthMs));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kFailSafeExpiryLengthMsFieldId:
+        case to_underlying(Fields::kFailSafeExpiryLengthMs):
             ReturnErrorOnFailure(DataModel::Decode(reader, failSafeExpiryLengthMs));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace BasicCommissioningInfoType
-} // namespace GeneralCommissioning
 
-namespace NetworkCommissioning {
-namespace ThreadInterfaceScanResult {
+namespace Commands {
+namespace ArmFailSafe {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDiscoveryResponseFieldId), discoveryResponse));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExpiryLengthSeconds)), expiryLengthSeconds));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kDiscoveryResponseFieldId:
+        case to_underlying(Fields::kExpiryLengthSeconds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, expiryLengthSeconds));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ArmFailSafe.
+namespace ArmFailSafeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ArmFailSafeResponse.
+namespace SetRegulatoryConfig {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocation)), location));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCountryCode)), countryCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLocation):
+            ReturnErrorOnFailure(DataModel::Decode(reader, location));
+            break;
+        case to_underlying(Fields::kCountryCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, countryCode));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetRegulatoryConfig.
+namespace SetRegulatoryConfigResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetRegulatoryConfigResponse.
+namespace CommissioningComplete {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CommissioningComplete.
+namespace CommissioningCompleteResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CommissioningCompleteResponse.
+} // namespace Commands
+} // namespace GeneralCommissioning
+namespace NetworkCommissioning {
+namespace ThreadInterfaceScanResult {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDiscoveryResponse)), discoveryResponse));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kDiscoveryResponse):
             ReturnErrorOnFailure(DataModel::Decode(reader, discoveryResponse));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -369,245 +4696,1096 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSecurityFieldId), security));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSsidFieldId), ssid));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBssidFieldId), bssid));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kChannelFieldId), channel));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFrequencyBandFieldId), frequencyBand));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSecurity)), security));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSsid)), ssid));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBssid)), bssid));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kChannel)), channel));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFrequencyBand)), frequencyBand));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kSecurityFieldId:
+        case to_underlying(Fields::kSecurity):
             ReturnErrorOnFailure(DataModel::Decode(reader, security));
             break;
-        case kSsidFieldId:
+        case to_underlying(Fields::kSsid):
             ReturnErrorOnFailure(DataModel::Decode(reader, ssid));
             break;
-        case kBssidFieldId:
+        case to_underlying(Fields::kBssid):
             ReturnErrorOnFailure(DataModel::Decode(reader, bssid));
             break;
-        case kChannelFieldId:
+        case to_underlying(Fields::kChannel):
             ReturnErrorOnFailure(DataModel::Decode(reader, channel));
             break;
-        case kFrequencyBandFieldId:
+        case to_underlying(Fields::kFrequencyBand):
             ReturnErrorOnFailure(DataModel::Decode(reader, frequencyBand));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace WiFiInterfaceScanResult
+
+namespace Commands {
+namespace ScanNetworks {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSsid)), ssid));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSsid):
+            ReturnErrorOnFailure(DataModel::Decode(reader, ssid));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ScanNetworks.
+namespace ScanNetworksResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kWifiScanResults)), wifiScanResults));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kThreadScanResults)), threadScanResults));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        case to_underlying(Fields::kWifiScanResults):
+            ReturnErrorOnFailure(DataModel::Decode(reader, wifiScanResults));
+            break;
+        case to_underlying(Fields::kThreadScanResults):
+            ReturnErrorOnFailure(DataModel::Decode(reader, threadScanResults));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ScanNetworksResponse.
+namespace AddWiFiNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSsid)), ssid));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCredentials)), credentials));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSsid):
+            ReturnErrorOnFailure(DataModel::Decode(reader, ssid));
+            break;
+        case to_underlying(Fields::kCredentials):
+            ReturnErrorOnFailure(DataModel::Decode(reader, credentials));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddWiFiNetwork.
+namespace AddWiFiNetworkResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddWiFiNetworkResponse.
+namespace UpdateWiFiNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSsid)), ssid));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCredentials)), credentials));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSsid):
+            ReturnErrorOnFailure(DataModel::Decode(reader, ssid));
+            break;
+        case to_underlying(Fields::kCredentials):
+            ReturnErrorOnFailure(DataModel::Decode(reader, credentials));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UpdateWiFiNetwork.
+namespace UpdateWiFiNetworkResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UpdateWiFiNetworkResponse.
+namespace AddThreadNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOperationalDataset)), operationalDataset));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kOperationalDataset):
+            ReturnErrorOnFailure(DataModel::Decode(reader, operationalDataset));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddThreadNetwork.
+namespace AddThreadNetworkResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddThreadNetworkResponse.
+namespace UpdateThreadNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOperationalDataset)), operationalDataset));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kOperationalDataset):
+            ReturnErrorOnFailure(DataModel::Decode(reader, operationalDataset));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UpdateThreadNetwork.
+namespace UpdateThreadNetworkResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UpdateThreadNetworkResponse.
+namespace RemoveNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNetworkID)), networkID));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNetworkID):
+            ReturnErrorOnFailure(DataModel::Decode(reader, networkID));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveNetwork.
+namespace RemoveNetworkResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveNetworkResponse.
+namespace EnableNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNetworkID)), networkID));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNetworkID):
+            ReturnErrorOnFailure(DataModel::Decode(reader, networkID));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnableNetwork.
+namespace EnableNetworkResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnableNetworkResponse.
+namespace DisableNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNetworkID)), networkID));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBreadcrumb)), breadcrumb));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNetworkID):
+            ReturnErrorOnFailure(DataModel::Decode(reader, networkID));
+            break;
+        case to_underlying(Fields::kBreadcrumb):
+            ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb));
+            break;
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace DisableNetwork.
+namespace DisableNetworkResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorCode)), errorCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kErrorCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorCode));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace DisableNetworkResponse.
+namespace GetLastNetworkCommissioningResult {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutMs)), timeoutMs));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTimeoutMs):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutMs));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetLastNetworkCommissioningResult.
+} // namespace Commands
 } // namespace NetworkCommissioning
-
 namespace DiagnosticLogs {
-} // namespace DiagnosticLogs
 
+namespace Commands {
+namespace RetrieveLogsRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIntent)), intent));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRequestedProtocol)), requestedProtocol));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransferFileDesignator)), transferFileDesignator));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kIntent):
+            ReturnErrorOnFailure(DataModel::Decode(reader, intent));
+            break;
+        case to_underlying(Fields::kRequestedProtocol):
+            ReturnErrorOnFailure(DataModel::Decode(reader, requestedProtocol));
+            break;
+        case to_underlying(Fields::kTransferFileDesignator):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transferFileDesignator));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RetrieveLogsRequest.
+namespace RetrieveLogsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kContent)), content));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeStamp)), timeStamp));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeSinceBoot)), timeSinceBoot));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kContent):
+            ReturnErrorOnFailure(DataModel::Decode(reader, content));
+            break;
+        case to_underlying(Fields::kTimeStamp):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeStamp));
+            break;
+        case to_underlying(Fields::kTimeSinceBoot):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeSinceBoot));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RetrieveLogsResponse.
+} // namespace Commands
+} // namespace DiagnosticLogs
 namespace GeneralDiagnostics {
 namespace NetworkInterfaceType {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricConnectedFieldId), fabricConnected));
-    ReturnErrorOnFailure(
-        DataModel::Encode(writer, TLV::ContextTag(kOffPremiseServicesReachableIPv4FieldId), offPremiseServicesReachableIPv4));
-    ReturnErrorOnFailure(
-        DataModel::Encode(writer, TLV::ContextTag(kOffPremiseServicesReachableIPv6FieldId), offPremiseServicesReachableIPv6));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kHardwareAddressFieldId), hardwareAddress));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTypeFieldId), type));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFabricConnected)), fabricConnected));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOffPremiseServicesReachableIPv4)),
+                                           offPremiseServicesReachableIPv4));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOffPremiseServicesReachableIPv6)),
+                                           offPremiseServicesReachableIPv6));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kHardwareAddress)), hardwareAddress));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kType)), type));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kNameFieldId:
+        case to_underlying(Fields::kName):
             ReturnErrorOnFailure(DataModel::Decode(reader, name));
             break;
-        case kFabricConnectedFieldId:
+        case to_underlying(Fields::kFabricConnected):
             ReturnErrorOnFailure(DataModel::Decode(reader, fabricConnected));
             break;
-        case kOffPremiseServicesReachableIPv4FieldId:
+        case to_underlying(Fields::kOffPremiseServicesReachableIPv4):
             ReturnErrorOnFailure(DataModel::Decode(reader, offPremiseServicesReachableIPv4));
             break;
-        case kOffPremiseServicesReachableIPv6FieldId:
+        case to_underlying(Fields::kOffPremiseServicesReachableIPv6):
             ReturnErrorOnFailure(DataModel::Decode(reader, offPremiseServicesReachableIPv6));
             break;
-        case kHardwareAddressFieldId:
+        case to_underlying(Fields::kHardwareAddress):
             ReturnErrorOnFailure(DataModel::Decode(reader, hardwareAddress));
             break;
-        case kTypeFieldId:
+        case to_underlying(Fields::kType):
             ReturnErrorOnFailure(DataModel::Decode(reader, type));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace NetworkInterfaceType
-} // namespace GeneralDiagnostics
 
+namespace Commands {
+} // namespace Commands
+} // namespace GeneralDiagnostics
 namespace SoftwareDiagnostics {
 namespace ThreadMetrics {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIdFieldId), id));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStackFreeCurrentFieldId), stackFreeCurrent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStackFreeMinimumFieldId), stackFreeMinimum));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStackSizeFieldId), stackSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kId)), id));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStackFreeCurrent)), stackFreeCurrent));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStackFreeMinimum)), stackFreeMinimum));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStackSize)), stackSize));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kIdFieldId:
+        case to_underlying(Fields::kId):
             ReturnErrorOnFailure(DataModel::Decode(reader, id));
             break;
-        case kNameFieldId:
+        case to_underlying(Fields::kName):
             ReturnErrorOnFailure(DataModel::Decode(reader, name));
             break;
-        case kStackFreeCurrentFieldId:
+        case to_underlying(Fields::kStackFreeCurrent):
             ReturnErrorOnFailure(DataModel::Decode(reader, stackFreeCurrent));
             break;
-        case kStackFreeMinimumFieldId:
+        case to_underlying(Fields::kStackFreeMinimum):
             ReturnErrorOnFailure(DataModel::Decode(reader, stackFreeMinimum));
             break;
-        case kStackSizeFieldId:
+        case to_underlying(Fields::kStackSize):
             ReturnErrorOnFailure(DataModel::Decode(reader, stackSize));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace ThreadMetrics
-} // namespace SoftwareDiagnostics
 
-namespace ThreadNetworkDiagnostics {
-namespace NeighborTable {
+namespace Commands {
+namespace ResetWatermarks {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kExtAddressFieldId), extAddress));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAgeFieldId), age));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRloc16FieldId), rloc16));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLinkFrameCounterFieldId), linkFrameCounter));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMleFrameCounterFieldId), mleFrameCounter));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLqiFieldId), lqi));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAverageRssiFieldId), averageRssi));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLastRssiFieldId), lastRssi));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFrameErrorRateFieldId), frameErrorRate));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMessageErrorRateFieldId), messageErrorRate));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRxOnWhenIdleFieldId), rxOnWhenIdle));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFullThreadDeviceFieldId), fullThreadDevice));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFullNetworkDataFieldId), fullNetworkData));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIsChildFieldId), isChild));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kExtAddressFieldId:
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ResetWatermarks.
+} // namespace Commands
+} // namespace SoftwareDiagnostics
+namespace ThreadNetworkDiagnostics {
+namespace NeighborTable {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExtAddress)), extAddress));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAge)), age));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRloc16)), rloc16));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLinkFrameCounter)), linkFrameCounter));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMleFrameCounter)), mleFrameCounter));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLqi)), lqi));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAverageRssi)), averageRssi));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLastRssi)), lastRssi));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFrameErrorRate)), frameErrorRate));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageErrorRate)), messageErrorRate));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRxOnWhenIdle)), rxOnWhenIdle));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFullThreadDevice)), fullThreadDevice));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFullNetworkData)), fullNetworkData));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIsChild)), isChild));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kExtAddress):
             ReturnErrorOnFailure(DataModel::Decode(reader, extAddress));
             break;
-        case kAgeFieldId:
+        case to_underlying(Fields::kAge):
             ReturnErrorOnFailure(DataModel::Decode(reader, age));
             break;
-        case kRloc16FieldId:
+        case to_underlying(Fields::kRloc16):
             ReturnErrorOnFailure(DataModel::Decode(reader, rloc16));
             break;
-        case kLinkFrameCounterFieldId:
+        case to_underlying(Fields::kLinkFrameCounter):
             ReturnErrorOnFailure(DataModel::Decode(reader, linkFrameCounter));
             break;
-        case kMleFrameCounterFieldId:
+        case to_underlying(Fields::kMleFrameCounter):
             ReturnErrorOnFailure(DataModel::Decode(reader, mleFrameCounter));
             break;
-        case kLqiFieldId:
+        case to_underlying(Fields::kLqi):
             ReturnErrorOnFailure(DataModel::Decode(reader, lqi));
             break;
-        case kAverageRssiFieldId:
+        case to_underlying(Fields::kAverageRssi):
             ReturnErrorOnFailure(DataModel::Decode(reader, averageRssi));
             break;
-        case kLastRssiFieldId:
+        case to_underlying(Fields::kLastRssi):
             ReturnErrorOnFailure(DataModel::Decode(reader, lastRssi));
             break;
-        case kFrameErrorRateFieldId:
+        case to_underlying(Fields::kFrameErrorRate):
             ReturnErrorOnFailure(DataModel::Decode(reader, frameErrorRate));
             break;
-        case kMessageErrorRateFieldId:
+        case to_underlying(Fields::kMessageErrorRate):
             ReturnErrorOnFailure(DataModel::Decode(reader, messageErrorRate));
             break;
-        case kRxOnWhenIdleFieldId:
+        case to_underlying(Fields::kRxOnWhenIdle):
             ReturnErrorOnFailure(DataModel::Decode(reader, rxOnWhenIdle));
             break;
-        case kFullThreadDeviceFieldId:
+        case to_underlying(Fields::kFullThreadDevice):
             ReturnErrorOnFailure(DataModel::Decode(reader, fullThreadDevice));
             break;
-        case kFullNetworkDataFieldId:
+        case to_underlying(Fields::kFullNetworkData):
             ReturnErrorOnFailure(DataModel::Decode(reader, fullNetworkData));
             break;
-        case kIsChildFieldId:
+        case to_underlying(Fields::kIsChild):
             ReturnErrorOnFailure(DataModel::Decode(reader, isChild));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -619,72 +5797,82 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kActiveTimestampPresentFieldId), activeTimestampPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPendingTimestampPresentFieldId), pendingTimestampPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMasterKeyPresentFieldId), masterKeyPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNetworkNamePresentFieldId), networkNamePresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kExtendedPanIdPresentFieldId), extendedPanIdPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMeshLocalPrefixPresentFieldId), meshLocalPrefixPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDelayPresentFieldId), delayPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPanIdPresentFieldId), panIdPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kChannelPresentFieldId), channelPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPskcPresentFieldId), pskcPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSecurityPolicyPresentFieldId), securityPolicyPresent));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kChannelMaskPresentFieldId), channelMaskPresent));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kActiveTimestampPresent)), activeTimestampPresent));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPendingTimestampPresent)), pendingTimestampPresent));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMasterKeyPresent)), masterKeyPresent));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNetworkNamePresent)), networkNamePresent));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExtendedPanIdPresent)), extendedPanIdPresent));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMeshLocalPrefixPresent)), meshLocalPrefixPresent));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDelayPresent)), delayPresent));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPanIdPresent)), panIdPresent));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kChannelPresent)), channelPresent));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPskcPresent)), pskcPresent));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSecurityPolicyPresent)), securityPolicyPresent));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kChannelMaskPresent)), channelMaskPresent));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kActiveTimestampPresentFieldId:
+        case to_underlying(Fields::kActiveTimestampPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, activeTimestampPresent));
             break;
-        case kPendingTimestampPresentFieldId:
+        case to_underlying(Fields::kPendingTimestampPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, pendingTimestampPresent));
             break;
-        case kMasterKeyPresentFieldId:
+        case to_underlying(Fields::kMasterKeyPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, masterKeyPresent));
             break;
-        case kNetworkNamePresentFieldId:
+        case to_underlying(Fields::kNetworkNamePresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, networkNamePresent));
             break;
-        case kExtendedPanIdPresentFieldId:
+        case to_underlying(Fields::kExtendedPanIdPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, extendedPanIdPresent));
             break;
-        case kMeshLocalPrefixPresentFieldId:
+        case to_underlying(Fields::kMeshLocalPrefixPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, meshLocalPrefixPresent));
             break;
-        case kDelayPresentFieldId:
+        case to_underlying(Fields::kDelayPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, delayPresent));
             break;
-        case kPanIdPresentFieldId:
+        case to_underlying(Fields::kPanIdPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, panIdPresent));
             break;
-        case kChannelPresentFieldId:
+        case to_underlying(Fields::kChannelPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, channelPresent));
             break;
-        case kPskcPresentFieldId:
+        case to_underlying(Fields::kPskcPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, pskcPresent));
             break;
-        case kSecurityPolicyPresentFieldId:
+        case to_underlying(Fields::kSecurityPolicyPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, securityPolicyPresent));
             break;
-        case kChannelMaskPresentFieldId:
+        case to_underlying(Fields::kChannelMaskPresent):
             ReturnErrorOnFailure(DataModel::Decode(reader, channelMaskPresent));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -696,64 +5884,67 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kExtAddressFieldId), extAddress));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRloc16FieldId), rloc16));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRouterIdFieldId), routerId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNextHopFieldId), nextHop));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPathCostFieldId), pathCost));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLQIInFieldId), lQIIn));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLQIOutFieldId), lQIOut));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAgeFieldId), age));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAllocatedFieldId), allocated));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLinkEstablishedFieldId), linkEstablished));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExtAddress)), extAddress));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRloc16)), rloc16));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRouterId)), routerId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNextHop)), nextHop));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPathCost)), pathCost));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLQIIn)), lQIIn));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLQIOut)), lQIOut));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAge)), age));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAllocated)), allocated));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLinkEstablished)), linkEstablished));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kExtAddressFieldId:
+        case to_underlying(Fields::kExtAddress):
             ReturnErrorOnFailure(DataModel::Decode(reader, extAddress));
             break;
-        case kRloc16FieldId:
+        case to_underlying(Fields::kRloc16):
             ReturnErrorOnFailure(DataModel::Decode(reader, rloc16));
             break;
-        case kRouterIdFieldId:
+        case to_underlying(Fields::kRouterId):
             ReturnErrorOnFailure(DataModel::Decode(reader, routerId));
             break;
-        case kNextHopFieldId:
+        case to_underlying(Fields::kNextHop):
             ReturnErrorOnFailure(DataModel::Decode(reader, nextHop));
             break;
-        case kPathCostFieldId:
+        case to_underlying(Fields::kPathCost):
             ReturnErrorOnFailure(DataModel::Decode(reader, pathCost));
             break;
-        case kLQIInFieldId:
+        case to_underlying(Fields::kLQIIn):
             ReturnErrorOnFailure(DataModel::Decode(reader, lQIIn));
             break;
-        case kLQIOutFieldId:
+        case to_underlying(Fields::kLQIOut):
             ReturnErrorOnFailure(DataModel::Decode(reader, lQIOut));
             break;
-        case kAgeFieldId:
+        case to_underlying(Fields::kAge):
             ReturnErrorOnFailure(DataModel::Decode(reader, age));
             break;
-        case kAllocatedFieldId:
+        case to_underlying(Fields::kAllocated):
             ReturnErrorOnFailure(DataModel::Decode(reader, allocated));
             break;
-        case kLinkEstablishedFieldId:
+        case to_underlying(Fields::kLinkEstablished):
             ReturnErrorOnFailure(DataModel::Decode(reader, linkEstablished));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -765,103 +5956,461 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRotationTimeFieldId), rotationTime));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFlagsFieldId), flags));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRotationTime)), rotationTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFlags)), flags));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kRotationTimeFieldId:
+        case to_underlying(Fields::kRotationTime):
             ReturnErrorOnFailure(DataModel::Decode(reader, rotationTime));
             break;
-        case kFlagsFieldId:
+        case to_underlying(Fields::kFlags):
             ReturnErrorOnFailure(DataModel::Decode(reader, flags));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace SecurityPolicy
-} // namespace ThreadNetworkDiagnostics
 
-namespace WiFiNetworkDiagnostics {
-} // namespace WiFiNetworkDiagnostics
-
-namespace EthernetNetworkDiagnostics {
-} // namespace EthernetNetworkDiagnostics
-
-namespace BridgedDeviceBasic {
-} // namespace BridgedDeviceBasic
-
-namespace Switch {
-} // namespace Switch
-
-namespace AdministratorCommissioning {
-} // namespace AdministratorCommissioning
-
-namespace OperationalCredentials {
-namespace FabricDescriptor {
+namespace Commands {
+namespace ResetCounts {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRootPublicKeyFieldId), rootPublicKey));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kVendorIdFieldId), vendorId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIdFieldId), fabricId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNodeIdFieldId), nodeId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLabelFieldId), label));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kFabricIndexFieldId:
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ResetCounts.
+} // namespace Commands
+} // namespace ThreadNetworkDiagnostics
+namespace WiFiNetworkDiagnostics {
+
+namespace Commands {
+namespace ResetCounts {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ResetCounts.
+} // namespace Commands
+} // namespace WiFiNetworkDiagnostics
+namespace EthernetNetworkDiagnostics {
+
+namespace Commands {
+namespace ResetCounts {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ResetCounts.
+} // namespace Commands
+} // namespace EthernetNetworkDiagnostics
+namespace BridgedDeviceBasic {
+
+namespace Commands {
+namespace StartUp {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StartUp.
+namespace ShutDown {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ShutDown.
+namespace Leave {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Leave.
+namespace ReachableChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ReachableChanged.
+} // namespace Commands
+} // namespace BridgedDeviceBasic
+namespace Switch {
+
+namespace Commands {
+} // namespace Commands
+} // namespace Switch
+namespace AdministratorCommissioning {
+
+namespace Commands {
+namespace OpenCommissioningWindow {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCommissioningTimeout)), commissioningTimeout));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPAKEVerifier)), pAKEVerifier));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDiscriminator)), discriminator));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIterations)), iterations));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSalt)), salt));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPasscodeID)), passcodeID));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCommissioningTimeout):
+            ReturnErrorOnFailure(DataModel::Decode(reader, commissioningTimeout));
+            break;
+        case to_underlying(Fields::kPAKEVerifier):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pAKEVerifier));
+            break;
+        case to_underlying(Fields::kDiscriminator):
+            ReturnErrorOnFailure(DataModel::Decode(reader, discriminator));
+            break;
+        case to_underlying(Fields::kIterations):
+            ReturnErrorOnFailure(DataModel::Decode(reader, iterations));
+            break;
+        case to_underlying(Fields::kSalt):
+            ReturnErrorOnFailure(DataModel::Decode(reader, salt));
+            break;
+        case to_underlying(Fields::kPasscodeID):
+            ReturnErrorOnFailure(DataModel::Decode(reader, passcodeID));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OpenCommissioningWindow.
+namespace OpenBasicCommissioningWindow {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCommissioningTimeout)), commissioningTimeout));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCommissioningTimeout):
+            ReturnErrorOnFailure(DataModel::Decode(reader, commissioningTimeout));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OpenBasicCommissioningWindow.
+namespace RevokeCommissioning {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RevokeCommissioning.
+} // namespace Commands
+} // namespace AdministratorCommissioning
+namespace OperationalCredentials {
+namespace FabricDescriptor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFabricIndex)), fabricIndex));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRootPublicKey)), rootPublicKey));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kVendorId)), vendorId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFabricId)), fabricId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNodeId)), nodeId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLabel)), label));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kFabricIndex):
             ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex));
             break;
-        case kRootPublicKeyFieldId:
+        case to_underlying(Fields::kRootPublicKey):
             ReturnErrorOnFailure(DataModel::Decode(reader, rootPublicKey));
             break;
-        case kVendorIdFieldId:
+        case to_underlying(Fields::kVendorId):
             ReturnErrorOnFailure(DataModel::Decode(reader, vendorId));
             break;
-        case kFabricIdFieldId:
+        case to_underlying(Fields::kFabricId):
             ReturnErrorOnFailure(DataModel::Decode(reader, fabricId));
             break;
-        case kNodeIdFieldId:
+        case to_underlying(Fields::kNodeId):
             ReturnErrorOnFailure(DataModel::Decode(reader, nodeId));
             break;
-        case kLabelFieldId:
+        case to_underlying(Fields::kLabel):
             ReturnErrorOnFailure(DataModel::Decode(reader, label));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -873,317 +6422,5782 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNocFieldId), noc));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFabricIndex)), fabricIndex));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNoc)), noc));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kFabricIndexFieldId:
+        case to_underlying(Fields::kFabricIndex):
             ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex));
             break;
-        case kNocFieldId:
+        case to_underlying(Fields::kNoc):
             ReturnErrorOnFailure(DataModel::Decode(reader, noc));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace NOCStruct
-} // namespace OperationalCredentials
 
+namespace Commands {
+namespace AttestationRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAttestationNonce)), attestationNonce));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAttestationNonce):
+            ReturnErrorOnFailure(DataModel::Decode(reader, attestationNonce));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AttestationRequest.
+namespace AttestationResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAttestationElements)), attestationElements));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSignature)), signature));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAttestationElements):
+            ReturnErrorOnFailure(DataModel::Decode(reader, attestationElements));
+            break;
+        case to_underlying(Fields::kSignature):
+            ReturnErrorOnFailure(DataModel::Decode(reader, signature));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AttestationResponse.
+namespace CertificateChainRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCertificateType)), certificateType));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCertificateType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, certificateType));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CertificateChainRequest.
+namespace CertificateChainResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCertificate)), certificate));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCertificate):
+            ReturnErrorOnFailure(DataModel::Decode(reader, certificate));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CertificateChainResponse.
+namespace OpCSRRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCSRNonce)), cSRNonce));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCSRNonce):
+            ReturnErrorOnFailure(DataModel::Decode(reader, cSRNonce));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OpCSRRequest.
+namespace OpCSRResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNOCSRElements)), nOCSRElements));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAttestationSignature)), attestationSignature));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNOCSRElements):
+            ReturnErrorOnFailure(DataModel::Decode(reader, nOCSRElements));
+            break;
+        case to_underlying(Fields::kAttestationSignature):
+            ReturnErrorOnFailure(DataModel::Decode(reader, attestationSignature));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OpCSRResponse.
+namespace AddNOC {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNOCValue)), nOCValue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kICACValue)), iCACValue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIPKValue)), iPKValue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCaseAdminNode)), caseAdminNode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAdminVendorId)), adminVendorId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNOCValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, nOCValue));
+            break;
+        case to_underlying(Fields::kICACValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, iCACValue));
+            break;
+        case to_underlying(Fields::kIPKValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, iPKValue));
+            break;
+        case to_underlying(Fields::kCaseAdminNode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, caseAdminNode));
+            break;
+        case to_underlying(Fields::kAdminVendorId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, adminVendorId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddNOC.
+namespace UpdateNOC {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNOCValue)), nOCValue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kICACValue)), iCACValue));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNOCValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, nOCValue));
+            break;
+        case to_underlying(Fields::kICACValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, iCACValue));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UpdateNOC.
+namespace NOCResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatusCode)), statusCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFabricIndex)), fabricIndex));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDebugText)), debugText));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatusCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, statusCode));
+            break;
+        case to_underlying(Fields::kFabricIndex):
+            ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex));
+            break;
+        case to_underlying(Fields::kDebugText):
+            ReturnErrorOnFailure(DataModel::Decode(reader, debugText));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace NOCResponse.
+namespace UpdateFabricLabel {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLabel)), label));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLabel):
+            ReturnErrorOnFailure(DataModel::Decode(reader, label));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UpdateFabricLabel.
+namespace RemoveFabric {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFabricIndex)), fabricIndex));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kFabricIndex):
+            ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveFabric.
+namespace AddTrustedRootCertificate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRootCertificate)), rootCertificate));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kRootCertificate):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rootCertificate));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AddTrustedRootCertificate.
+namespace RemoveTrustedRootCertificate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTrustedRootIdentifier)), trustedRootIdentifier));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTrustedRootIdentifier):
+            ReturnErrorOnFailure(DataModel::Decode(reader, trustedRootIdentifier));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RemoveTrustedRootCertificate.
+} // namespace Commands
+} // namespace OperationalCredentials
 namespace FixedLabel {
 namespace LabelStruct {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLabelFieldId), label));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kValueFieldId), value));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLabel)), label));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kValue)), value));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kLabelFieldId:
+        case to_underlying(Fields::kLabel):
             ReturnErrorOnFailure(DataModel::Decode(reader, label));
             break;
-        case kValueFieldId:
+        case to_underlying(Fields::kValue):
             ReturnErrorOnFailure(DataModel::Decode(reader, value));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace LabelStruct
+
+namespace Commands {
+} // namespace Commands
 } // namespace FixedLabel
-
 namespace ShadeConfiguration {
+
+namespace Commands {
+} // namespace Commands
 } // namespace ShadeConfiguration
-
 namespace DoorLock {
+
+namespace Commands {
+namespace LockDoor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LockDoor.
+namespace LockDoorResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LockDoorResponse.
+namespace UnlockDoor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UnlockDoor.
+namespace UnlockDoorResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UnlockDoorResponse.
+namespace Toggle {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Toggle.
+namespace ToggleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ToggleResponse.
+namespace UnlockWithTimeout {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeoutInSeconds)), timeoutInSeconds));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTimeoutInSeconds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeoutInSeconds));
+            break;
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UnlockWithTimeout.
+namespace UnlockWithTimeoutResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UnlockWithTimeoutResponse.
+namespace GetLogRecord {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogIndex)), logIndex));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLogIndex):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logIndex));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetLogRecord.
+namespace GetLogRecordResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogEntryId)), logEntryId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimestamp)), timestamp));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEventType)), eventType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSource)), source));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEventIdOrAlarmCode)), eventIdOrAlarmCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLogEntryId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logEntryId));
+            break;
+        case to_underlying(Fields::kTimestamp):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timestamp));
+            break;
+        case to_underlying(Fields::kEventType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, eventType));
+            break;
+        case to_underlying(Fields::kSource):
+            ReturnErrorOnFailure(DataModel::Decode(reader, source));
+            break;
+        case to_underlying(Fields::kEventIdOrAlarmCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, eventIdOrAlarmCode));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetLogRecordResponse.
+namespace SetPin {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserStatus)), userStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserType)), userType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kUserStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userStatus));
+            break;
+        case to_underlying(Fields::kUserType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userType));
+            break;
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetPin.
+namespace SetPinResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetPinResponse.
+namespace GetPin {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetPin.
+namespace GetPinResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserStatus)), userStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserType)), userType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kUserStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userStatus));
+            break;
+        case to_underlying(Fields::kUserType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userType));
+            break;
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetPinResponse.
+namespace ClearPin {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearPin.
+namespace ClearPinResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearPinResponse.
+namespace ClearAllPins {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearAllPins.
+namespace ClearAllPinsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearAllPinsResponse.
+namespace SetUserStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserStatus)), userStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kUserStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetUserStatus.
+namespace SetUserStatusResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetUserStatusResponse.
+namespace GetUserStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetUserStatus.
+namespace GetUserStatusResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetUserStatusResponse.
+namespace SetWeekdaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDaysMask)), daysMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartHour)), startHour));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartMinute)), startMinute));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEndHour)), endHour));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEndMinute)), endMinute));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kDaysMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, daysMask));
+            break;
+        case to_underlying(Fields::kStartHour):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startHour));
+            break;
+        case to_underlying(Fields::kStartMinute):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startMinute));
+            break;
+        case to_underlying(Fields::kEndHour):
+            ReturnErrorOnFailure(DataModel::Decode(reader, endHour));
+            break;
+        case to_underlying(Fields::kEndMinute):
+            ReturnErrorOnFailure(DataModel::Decode(reader, endMinute));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetWeekdaySchedule.
+namespace SetWeekdayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetWeekdayScheduleResponse.
+namespace GetWeekdaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetWeekdaySchedule.
+namespace GetWeekdayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDaysMask)), daysMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartHour)), startHour));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartMinute)), startMinute));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEndHour)), endHour));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEndMinute)), endMinute));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kDaysMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, daysMask));
+            break;
+        case to_underlying(Fields::kStartHour):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startHour));
+            break;
+        case to_underlying(Fields::kStartMinute):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startMinute));
+            break;
+        case to_underlying(Fields::kEndHour):
+            ReturnErrorOnFailure(DataModel::Decode(reader, endHour));
+            break;
+        case to_underlying(Fields::kEndMinute):
+            ReturnErrorOnFailure(DataModel::Decode(reader, endMinute));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetWeekdayScheduleResponse.
+namespace ClearWeekdaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearWeekdaySchedule.
+namespace ClearWeekdayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearWeekdayScheduleResponse.
+namespace SetYeardaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalStartTime)), localStartTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalEndTime)), localEndTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kLocalStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localStartTime));
+            break;
+        case to_underlying(Fields::kLocalEndTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localEndTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetYeardaySchedule.
+namespace SetYeardayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetYeardayScheduleResponse.
+namespace GetYeardaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetYeardaySchedule.
+namespace GetYeardayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalStartTime)), localStartTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalEndTime)), localEndTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kLocalStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localStartTime));
+            break;
+        case to_underlying(Fields::kLocalEndTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localEndTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetYeardayScheduleResponse.
+namespace ClearYeardaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearYeardaySchedule.
+namespace ClearYeardayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearYeardayScheduleResponse.
+namespace SetHolidaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalStartTime)), localStartTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalEndTime)), localEndTime));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOperatingModeDuringHoliday)), operatingModeDuringHoliday));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kLocalStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localStartTime));
+            break;
+        case to_underlying(Fields::kLocalEndTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localEndTime));
+            break;
+        case to_underlying(Fields::kOperatingModeDuringHoliday):
+            ReturnErrorOnFailure(DataModel::Decode(reader, operatingModeDuringHoliday));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetHolidaySchedule.
+namespace SetHolidayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetHolidayScheduleResponse.
+namespace GetHolidaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetHolidaySchedule.
+namespace GetHolidayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalStartTime)), localStartTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalEndTime)), localEndTime));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOperatingModeDuringHoliday)), operatingModeDuringHoliday));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kLocalStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localStartTime));
+            break;
+        case to_underlying(Fields::kLocalEndTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localEndTime));
+            break;
+        case to_underlying(Fields::kOperatingModeDuringHoliday):
+            ReturnErrorOnFailure(DataModel::Decode(reader, operatingModeDuringHoliday));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetHolidayScheduleResponse.
+namespace ClearHolidaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kScheduleId)), scheduleId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kScheduleId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, scheduleId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearHolidaySchedule.
+namespace ClearHolidayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearHolidayScheduleResponse.
+namespace SetUserType {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserType)), userType));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kUserType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userType));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetUserType.
+namespace SetUserTypeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetUserTypeResponse.
+namespace GetUserType {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetUserType.
+namespace GetUserTypeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserType)), userType));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kUserType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userType));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetUserTypeResponse.
+namespace SetRfid {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserStatus)), userStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserType)), userType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kId)), id));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kUserStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userStatus));
+            break;
+        case to_underlying(Fields::kUserType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userType));
+            break;
+        case to_underlying(Fields::kId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, id));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetRfid.
+namespace SetRfidResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetRfidResponse.
+namespace GetRfid {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetRfid.
+namespace GetRfidResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserStatus)), userStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserType)), userType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRfid)), rfid));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kUserStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userStatus));
+            break;
+        case to_underlying(Fields::kUserType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userType));
+            break;
+        case to_underlying(Fields::kRfid):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rfid));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetRfidResponse.
+namespace ClearRfid {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearRfid.
+namespace ClearRfidResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearRfidResponse.
+namespace ClearAllRfids {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearAllRfids.
+namespace ClearAllRfidsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearAllRfidsResponse.
+namespace OperationEventNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSource)), source));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEventCode)), eventCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeStamp)), timeStamp));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSource):
+            ReturnErrorOnFailure(DataModel::Decode(reader, source));
+            break;
+        case to_underlying(Fields::kEventCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, eventCode));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        case to_underlying(Fields::kTimeStamp):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeStamp));
+            break;
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace OperationEventNotification.
+namespace ProgrammingEventNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSource)), source));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEventCode)), eventCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserId)), userId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPin)), pin));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserType)), userType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUserStatus)), userStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeStamp)), timeStamp));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSource):
+            ReturnErrorOnFailure(DataModel::Decode(reader, source));
+            break;
+        case to_underlying(Fields::kEventCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, eventCode));
+            break;
+        case to_underlying(Fields::kUserId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userId));
+            break;
+        case to_underlying(Fields::kPin):
+            ReturnErrorOnFailure(DataModel::Decode(reader, pin));
+            break;
+        case to_underlying(Fields::kUserType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userType));
+            break;
+        case to_underlying(Fields::kUserStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, userStatus));
+            break;
+        case to_underlying(Fields::kTimeStamp):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeStamp));
+            break;
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ProgrammingEventNotification.
+} // namespace Commands
 } // namespace DoorLock
-
 namespace WindowCovering {
+
+namespace Commands {
+namespace UpOrOpen {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace UpOrOpen.
+namespace DownOrClose {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace DownOrClose.
+namespace StopMotion {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StopMotion.
+namespace GoToLiftValue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLiftValue)), liftValue));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLiftValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, liftValue));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GoToLiftValue.
+namespace GoToLiftPercentage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLiftPercentageValue)), liftPercentageValue));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLiftPercent100thsValue)), liftPercent100thsValue));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLiftPercentageValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, liftPercentageValue));
+            break;
+        case to_underlying(Fields::kLiftPercent100thsValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, liftPercent100thsValue));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GoToLiftPercentage.
+namespace GoToTiltValue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTiltValue)), tiltValue));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTiltValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, tiltValue));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GoToTiltValue.
+namespace GoToTiltPercentage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTiltPercentageValue)), tiltPercentageValue));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTiltPercent100thsValue)), tiltPercent100thsValue));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTiltPercentageValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, tiltPercentageValue));
+            break;
+        case to_underlying(Fields::kTiltPercent100thsValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, tiltPercent100thsValue));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GoToTiltPercentage.
+} // namespace Commands
 } // namespace WindowCovering
-
 namespace BarrierControl {
+
+namespace Commands {
+namespace BarrierControlGoToPercent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPercentOpen)), percentOpen));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPercentOpen):
+            ReturnErrorOnFailure(DataModel::Decode(reader, percentOpen));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace BarrierControlGoToPercent.
+namespace BarrierControlStop {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace BarrierControlStop.
+} // namespace Commands
 } // namespace BarrierControl
-
 namespace PumpConfigurationAndControl {
+
+namespace Commands {
+} // namespace Commands
 } // namespace PumpConfigurationAndControl
-
 namespace Thermostat {
+
+namespace Commands {
+namespace SetpointRaiseLower {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMode)), mode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAmount)), amount));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mode));
+            break;
+        case to_underlying(Fields::kAmount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, amount));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetpointRaiseLower.
+namespace CurrentWeeklySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumberOfTransitionsForSequence)),
+                                           numberOfTransitionsForSequence));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDayOfWeekForSequence)), dayOfWeekForSequence));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kModeForSequence)), modeForSequence));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPayload)), payload));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNumberOfTransitionsForSequence):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numberOfTransitionsForSequence));
+            break;
+        case to_underlying(Fields::kDayOfWeekForSequence):
+            ReturnErrorOnFailure(DataModel::Decode(reader, dayOfWeekForSequence));
+            break;
+        case to_underlying(Fields::kModeForSequence):
+            ReturnErrorOnFailure(DataModel::Decode(reader, modeForSequence));
+            break;
+        case to_underlying(Fields::kPayload):
+            ReturnErrorOnFailure(DataModel::Decode(reader, payload));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CurrentWeeklySchedule.
+namespace SetWeeklySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumberOfTransitionsForSequence)),
+                                           numberOfTransitionsForSequence));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDayOfWeekForSequence)), dayOfWeekForSequence));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kModeForSequence)), modeForSequence));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPayload)), payload));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNumberOfTransitionsForSequence):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numberOfTransitionsForSequence));
+            break;
+        case to_underlying(Fields::kDayOfWeekForSequence):
+            ReturnErrorOnFailure(DataModel::Decode(reader, dayOfWeekForSequence));
+            break;
+        case to_underlying(Fields::kModeForSequence):
+            ReturnErrorOnFailure(DataModel::Decode(reader, modeForSequence));
+            break;
+        case to_underlying(Fields::kPayload):
+            ReturnErrorOnFailure(DataModel::Decode(reader, payload));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetWeeklySchedule.
+namespace RelayStatusLog {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeOfDay)), timeOfDay));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRelayStatus)), relayStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLocalTemperature)), localTemperature));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kHumidityInPercentage)), humidityInPercentage));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSetpoint)), setpoint));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUnreadEntries)), unreadEntries));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTimeOfDay):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeOfDay));
+            break;
+        case to_underlying(Fields::kRelayStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, relayStatus));
+            break;
+        case to_underlying(Fields::kLocalTemperature):
+            ReturnErrorOnFailure(DataModel::Decode(reader, localTemperature));
+            break;
+        case to_underlying(Fields::kHumidityInPercentage):
+            ReturnErrorOnFailure(DataModel::Decode(reader, humidityInPercentage));
+            break;
+        case to_underlying(Fields::kSetpoint):
+            ReturnErrorOnFailure(DataModel::Decode(reader, setpoint));
+            break;
+        case to_underlying(Fields::kUnreadEntries):
+            ReturnErrorOnFailure(DataModel::Decode(reader, unreadEntries));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RelayStatusLog.
+namespace GetWeeklySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDaysToReturn)), daysToReturn));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kModeToReturn)), modeToReturn));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kDaysToReturn):
+            ReturnErrorOnFailure(DataModel::Decode(reader, daysToReturn));
+            break;
+        case to_underlying(Fields::kModeToReturn):
+            ReturnErrorOnFailure(DataModel::Decode(reader, modeToReturn));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetWeeklySchedule.
+namespace ClearWeeklySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ClearWeeklySchedule.
+namespace GetRelayStatusLog {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetRelayStatusLog.
+} // namespace Commands
 } // namespace Thermostat
-
 namespace FanControl {
+
+namespace Commands {
+} // namespace Commands
 } // namespace FanControl
-
 namespace DehumidificationControl {
+
+namespace Commands {
+} // namespace Commands
 } // namespace DehumidificationControl
-
 namespace ThermostatUserInterfaceConfiguration {
+
+namespace Commands {
+} // namespace Commands
 } // namespace ThermostatUserInterfaceConfiguration
-
 namespace ColorControl {
+
+namespace Commands {
+namespace MoveToHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kHue)), hue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDirection)), direction));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kHue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, hue));
+            break;
+        case to_underlying(Fields::kDirection):
+            ReturnErrorOnFailure(DataModel::Decode(reader, direction));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveToHue.
+namespace MoveHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMoveMode)), moveMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRate)), rate));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMoveMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, moveMode));
+            break;
+        case to_underlying(Fields::kRate):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rate));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveHue.
+namespace StepHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepMode)), stepMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepSize)), stepSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStepMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepMode));
+            break;
+        case to_underlying(Fields::kStepSize):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepSize));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StepHue.
+namespace MoveToSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSaturation)), saturation));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSaturation):
+            ReturnErrorOnFailure(DataModel::Decode(reader, saturation));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveToSaturation.
+namespace MoveSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMoveMode)), moveMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRate)), rate));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMoveMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, moveMode));
+            break;
+        case to_underlying(Fields::kRate):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rate));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveSaturation.
+namespace StepSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepMode)), stepMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepSize)), stepSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStepMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepMode));
+            break;
+        case to_underlying(Fields::kStepSize):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepSize));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StepSaturation.
+namespace MoveToHueAndSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kHue)), hue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSaturation)), saturation));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kHue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, hue));
+            break;
+        case to_underlying(Fields::kSaturation):
+            ReturnErrorOnFailure(DataModel::Decode(reader, saturation));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveToHueAndSaturation.
+namespace MoveToColor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kColorX)), colorX));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kColorY)), colorY));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kColorX):
+            ReturnErrorOnFailure(DataModel::Decode(reader, colorX));
+            break;
+        case to_underlying(Fields::kColorY):
+            ReturnErrorOnFailure(DataModel::Decode(reader, colorY));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveToColor.
+namespace MoveColor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRateX)), rateX));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRateY)), rateY));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kRateX):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rateX));
+            break;
+        case to_underlying(Fields::kRateY):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rateY));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveColor.
+namespace StepColor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepX)), stepX));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepY)), stepY));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStepX):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepX));
+            break;
+        case to_underlying(Fields::kStepY):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepY));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StepColor.
+namespace MoveToColorTemperature {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kColorTemperature)), colorTemperature));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kColorTemperature):
+            ReturnErrorOnFailure(DataModel::Decode(reader, colorTemperature));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveToColorTemperature.
+namespace EnhancedMoveToHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEnhancedHue)), enhancedHue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDirection)), direction));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kEnhancedHue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, enhancedHue));
+            break;
+        case to_underlying(Fields::kDirection):
+            ReturnErrorOnFailure(DataModel::Decode(reader, direction));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnhancedMoveToHue.
+namespace EnhancedMoveHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMoveMode)), moveMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRate)), rate));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMoveMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, moveMode));
+            break;
+        case to_underlying(Fields::kRate):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rate));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnhancedMoveHue.
+namespace EnhancedStepHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepMode)), stepMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepSize)), stepSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStepMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepMode));
+            break;
+        case to_underlying(Fields::kStepSize):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepSize));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnhancedStepHue.
+namespace EnhancedMoveToHueAndSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEnhancedHue)), enhancedHue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSaturation)), saturation));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kEnhancedHue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, enhancedHue));
+            break;
+        case to_underlying(Fields::kSaturation):
+            ReturnErrorOnFailure(DataModel::Decode(reader, saturation));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EnhancedMoveToHueAndSaturation.
+namespace ColorLoopSet {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUpdateFlags)), updateFlags));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAction)), action));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDirection)), direction));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTime)), time));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartHue)), startHue));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kUpdateFlags):
+            ReturnErrorOnFailure(DataModel::Decode(reader, updateFlags));
+            break;
+        case to_underlying(Fields::kAction):
+            ReturnErrorOnFailure(DataModel::Decode(reader, action));
+            break;
+        case to_underlying(Fields::kDirection):
+            ReturnErrorOnFailure(DataModel::Decode(reader, direction));
+            break;
+        case to_underlying(Fields::kTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, time));
+            break;
+        case to_underlying(Fields::kStartHue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startHue));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ColorLoopSet.
+namespace StopMoveStep {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StopMoveStep.
+namespace MoveColorTemperature {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMoveMode)), moveMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kRate)), rate));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kColorTemperatureMinimum)), colorTemperatureMinimum));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kColorTemperatureMaximum)), colorTemperatureMaximum));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMoveMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, moveMode));
+            break;
+        case to_underlying(Fields::kRate):
+            ReturnErrorOnFailure(DataModel::Decode(reader, rate));
+            break;
+        case to_underlying(Fields::kColorTemperatureMinimum):
+            ReturnErrorOnFailure(DataModel::Decode(reader, colorTemperatureMinimum));
+            break;
+        case to_underlying(Fields::kColorTemperatureMaximum):
+            ReturnErrorOnFailure(DataModel::Decode(reader, colorTemperatureMaximum));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MoveColorTemperature.
+namespace StepColorTemperature {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepMode)), stepMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStepSize)), stepSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTransitionTime)), transitionTime));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kColorTemperatureMinimum)), colorTemperatureMinimum));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kColorTemperatureMaximum)), colorTemperatureMaximum));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsMask)), optionsMask));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionsOverride)), optionsOverride));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStepMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepMode));
+            break;
+        case to_underlying(Fields::kStepSize):
+            ReturnErrorOnFailure(DataModel::Decode(reader, stepSize));
+            break;
+        case to_underlying(Fields::kTransitionTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, transitionTime));
+            break;
+        case to_underlying(Fields::kColorTemperatureMinimum):
+            ReturnErrorOnFailure(DataModel::Decode(reader, colorTemperatureMinimum));
+            break;
+        case to_underlying(Fields::kColorTemperatureMaximum):
+            ReturnErrorOnFailure(DataModel::Decode(reader, colorTemperatureMaximum));
+            break;
+        case to_underlying(Fields::kOptionsMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsMask));
+            break;
+        case to_underlying(Fields::kOptionsOverride):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionsOverride));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StepColorTemperature.
+} // namespace Commands
 } // namespace ColorControl
-
 namespace BallastConfiguration {
+
+namespace Commands {
+} // namespace Commands
 } // namespace BallastConfiguration
-
 namespace IlluminanceMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace IlluminanceMeasurement
-
 namespace IlluminanceLevelSensing {
+
+namespace Commands {
+} // namespace Commands
 } // namespace IlluminanceLevelSensing
-
 namespace TemperatureMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace TemperatureMeasurement
-
 namespace PressureMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace PressureMeasurement
-
 namespace FlowMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace FlowMeasurement
-
 namespace RelativeHumidityMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace RelativeHumidityMeasurement
-
 namespace OccupancySensing {
+
+namespace Commands {
+} // namespace Commands
 } // namespace OccupancySensing
-
 namespace CarbonMonoxideConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace CarbonMonoxideConcentrationMeasurement
-
 namespace CarbonDioxideConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace CarbonDioxideConcentrationMeasurement
-
 namespace EthyleneConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace EthyleneConcentrationMeasurement
-
 namespace EthyleneOxideConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace EthyleneOxideConcentrationMeasurement
-
 namespace HydrogenConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace HydrogenConcentrationMeasurement
-
 namespace HydrogenSulphideConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace HydrogenSulphideConcentrationMeasurement
-
 namespace NitricOxideConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace NitricOxideConcentrationMeasurement
-
 namespace NitrogenDioxideConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace NitrogenDioxideConcentrationMeasurement
-
 namespace OxygenConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace OxygenConcentrationMeasurement
-
 namespace OzoneConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace OzoneConcentrationMeasurement
-
 namespace SulfurDioxideConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace SulfurDioxideConcentrationMeasurement
-
 namespace DissolvedOxygenConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace DissolvedOxygenConcentrationMeasurement
-
 namespace BromateConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace BromateConcentrationMeasurement
-
 namespace ChloraminesConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace ChloraminesConcentrationMeasurement
-
 namespace ChlorineConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace ChlorineConcentrationMeasurement
-
 namespace FecalColiformAndEColiConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace FecalColiformAndEColiConcentrationMeasurement
-
 namespace FluorideConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace FluorideConcentrationMeasurement
-
 namespace HaloaceticAcidsConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace HaloaceticAcidsConcentrationMeasurement
-
 namespace TotalTrihalomethanesConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace TotalTrihalomethanesConcentrationMeasurement
-
 namespace TotalColiformBacteriaConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace TotalColiformBacteriaConcentrationMeasurement
-
 namespace TurbidityConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace TurbidityConcentrationMeasurement
-
 namespace CopperConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace CopperConcentrationMeasurement
-
 namespace LeadConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace LeadConcentrationMeasurement
-
 namespace ManganeseConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace ManganeseConcentrationMeasurement
-
 namespace SulfateConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace SulfateConcentrationMeasurement
-
 namespace BromodichloromethaneConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace BromodichloromethaneConcentrationMeasurement
-
 namespace BromoformConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace BromoformConcentrationMeasurement
-
 namespace ChlorodibromomethaneConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace ChlorodibromomethaneConcentrationMeasurement
-
 namespace ChloroformConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace ChloroformConcentrationMeasurement
-
 namespace SodiumConcentrationMeasurement {
+
+namespace Commands {
+} // namespace Commands
 } // namespace SodiumConcentrationMeasurement
-
 namespace IasZone {
-} // namespace IasZone
 
+namespace Commands {
+namespace ZoneEnrollResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEnrollResponseCode)), enrollResponseCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneId)), zoneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kEnrollResponseCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, enrollResponseCode));
+            break;
+        case to_underlying(Fields::kZoneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ZoneEnrollResponse.
+namespace ZoneStatusChangeNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneStatus)), zoneStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExtendedStatus)), extendedStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneId)), zoneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDelay)), delay));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kZoneStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneStatus));
+            break;
+        case to_underlying(Fields::kExtendedStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, extendedStatus));
+            break;
+        case to_underlying(Fields::kZoneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneId));
+            break;
+        case to_underlying(Fields::kDelay):
+            ReturnErrorOnFailure(DataModel::Decode(reader, delay));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ZoneStatusChangeNotification.
+namespace InitiateNormalOperationMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace InitiateNormalOperationMode.
+namespace ZoneEnrollRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneType)), zoneType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kManufacturerCode)), manufacturerCode));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kZoneType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneType));
+            break;
+        case to_underlying(Fields::kManufacturerCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, manufacturerCode));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ZoneEnrollRequest.
+namespace InitiateTestMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTestModeDuration)), testModeDuration));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCurrentZoneSensitivityLevel)),
+                                           currentZoneSensitivityLevel));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTestModeDuration):
+            ReturnErrorOnFailure(DataModel::Decode(reader, testModeDuration));
+            break;
+        case to_underlying(Fields::kCurrentZoneSensitivityLevel):
+            ReturnErrorOnFailure(DataModel::Decode(reader, currentZoneSensitivityLevel));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace InitiateTestMode.
+namespace InitiateNormalOperationModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace InitiateNormalOperationModeResponse.
+namespace InitiateTestModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace InitiateTestModeResponse.
+} // namespace Commands
+} // namespace IasZone
 namespace IasAce {
 namespace IasAceZoneStatusResult {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kZoneIdFieldId), zoneId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kZoneStatusFieldId), zoneStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneId)), zoneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneStatus)), zoneStatus));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kZoneIdFieldId:
+        case to_underlying(Fields::kZoneId):
             ReturnErrorOnFailure(DataModel::Decode(reader, zoneId));
             break;
-        case kZoneStatusFieldId:
+        case to_underlying(Fields::kZoneStatus):
             ReturnErrorOnFailure(DataModel::Decode(reader, zoneStatus));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace IasAceZoneStatusResult
-} // namespace IasAce
 
-namespace IasWd {
-} // namespace IasWd
-
-namespace WakeOnLan {
-} // namespace WakeOnLan
-
-namespace TvChannel {
-namespace TvChannelInfo {
+namespace Commands {
+namespace Arm {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMajorNumberFieldId), majorNumber));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMinorNumberFieldId), minorNumber));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCallSignFieldId), callSign));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAffiliateCallSignFieldId), affiliateCallSign));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArmMode)), armMode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArmDisarmCode)), armDisarmCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneId)), zoneId));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kMajorNumberFieldId:
+        case to_underlying(Fields::kArmMode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, armMode));
+            break;
+        case to_underlying(Fields::kArmDisarmCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, armDisarmCode));
+            break;
+        case to_underlying(Fields::kZoneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Arm.
+namespace ArmResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArmNotification)), armNotification));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kArmNotification):
+            ReturnErrorOnFailure(DataModel::Decode(reader, armNotification));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ArmResponse.
+namespace Bypass {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumberOfZones)), numberOfZones));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneIds)), zoneIds));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArmDisarmCode)), armDisarmCode));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNumberOfZones):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numberOfZones));
+            break;
+        case to_underlying(Fields::kZoneIds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneIds));
+            break;
+        case to_underlying(Fields::kArmDisarmCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, armDisarmCode));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Bypass.
+namespace GetZoneIdMapResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection0)), section0));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection1)), section1));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection2)), section2));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection3)), section3));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection4)), section4));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection5)), section5));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection6)), section6));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection7)), section7));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection8)), section8));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection9)), section9));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection10)), section10));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection11)), section11));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection12)), section12));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection13)), section13));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection14)), section14));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSection15)), section15));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSection0):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section0));
+            break;
+        case to_underlying(Fields::kSection1):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section1));
+            break;
+        case to_underlying(Fields::kSection2):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section2));
+            break;
+        case to_underlying(Fields::kSection3):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section3));
+            break;
+        case to_underlying(Fields::kSection4):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section4));
+            break;
+        case to_underlying(Fields::kSection5):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section5));
+            break;
+        case to_underlying(Fields::kSection6):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section6));
+            break;
+        case to_underlying(Fields::kSection7):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section7));
+            break;
+        case to_underlying(Fields::kSection8):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section8));
+            break;
+        case to_underlying(Fields::kSection9):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section9));
+            break;
+        case to_underlying(Fields::kSection10):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section10));
+            break;
+        case to_underlying(Fields::kSection11):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section11));
+            break;
+        case to_underlying(Fields::kSection12):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section12));
+            break;
+        case to_underlying(Fields::kSection13):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section13));
+            break;
+        case to_underlying(Fields::kSection14):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section14));
+            break;
+        case to_underlying(Fields::kSection15):
+            ReturnErrorOnFailure(DataModel::Decode(reader, section15));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetZoneIdMapResponse.
+namespace Emergency {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Emergency.
+namespace GetZoneInformationResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneId)), zoneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneType)), zoneType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIeeeAddress)), ieeeAddress));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneLabel)), zoneLabel));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kZoneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneId));
+            break;
+        case to_underlying(Fields::kZoneType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneType));
+            break;
+        case to_underlying(Fields::kIeeeAddress):
+            ReturnErrorOnFailure(DataModel::Decode(reader, ieeeAddress));
+            break;
+        case to_underlying(Fields::kZoneLabel):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneLabel));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetZoneInformationResponse.
+namespace Fire {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Fire.
+namespace ZoneStatusChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneId)), zoneId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneStatus)), zoneStatus));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAudibleNotification)), audibleNotification));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneLabel)), zoneLabel));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kZoneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneId));
+            break;
+        case to_underlying(Fields::kZoneStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneStatus));
+            break;
+        case to_underlying(Fields::kAudibleNotification):
+            ReturnErrorOnFailure(DataModel::Decode(reader, audibleNotification));
+            break;
+        case to_underlying(Fields::kZoneLabel):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneLabel));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ZoneStatusChanged.
+namespace Panic {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Panic.
+namespace PanelStatusChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPanelStatus)), panelStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSecondsRemaining)), secondsRemaining));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAudibleNotification)), audibleNotification));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAlarmStatus)), alarmStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPanelStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, panelStatus));
+            break;
+        case to_underlying(Fields::kSecondsRemaining):
+            ReturnErrorOnFailure(DataModel::Decode(reader, secondsRemaining));
+            break;
+        case to_underlying(Fields::kAudibleNotification):
+            ReturnErrorOnFailure(DataModel::Decode(reader, audibleNotification));
+            break;
+        case to_underlying(Fields::kAlarmStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, alarmStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace PanelStatusChanged.
+namespace GetZoneIdMap {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetZoneIdMap.
+namespace GetPanelStatusResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPanelStatus)), panelStatus));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSecondsRemaining)), secondsRemaining));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAudibleNotification)), audibleNotification));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAlarmStatus)), alarmStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPanelStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, panelStatus));
+            break;
+        case to_underlying(Fields::kSecondsRemaining):
+            ReturnErrorOnFailure(DataModel::Decode(reader, secondsRemaining));
+            break;
+        case to_underlying(Fields::kAudibleNotification):
+            ReturnErrorOnFailure(DataModel::Decode(reader, audibleNotification));
+            break;
+        case to_underlying(Fields::kAlarmStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, alarmStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetPanelStatusResponse.
+namespace GetZoneInformation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneId)), zoneId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kZoneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetZoneInformation.
+namespace SetBypassedZoneList {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumberOfZones)), numberOfZones));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneIds)), zoneIds));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNumberOfZones):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numberOfZones));
+            break;
+        case to_underlying(Fields::kZoneIds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneIds));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SetBypassedZoneList.
+namespace GetPanelStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetPanelStatus.
+namespace BypassResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumberOfZones)), numberOfZones));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBypassResult)), bypassResult));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNumberOfZones):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numberOfZones));
+            break;
+        case to_underlying(Fields::kBypassResult):
+            ReturnErrorOnFailure(DataModel::Decode(reader, bypassResult));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace BypassResponse.
+namespace GetBypassedZoneList {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetBypassedZoneList.
+namespace GetZoneStatusResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneStatusComplete)), zoneStatusComplete));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumberOfZones)), numberOfZones));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneStatusResult)), zoneStatusResult));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kZoneStatusComplete):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneStatusComplete));
+            break;
+        case to_underlying(Fields::kNumberOfZones):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numberOfZones));
+            break;
+        case to_underlying(Fields::kZoneStatusResult):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneStatusResult));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetZoneStatusResponse.
+namespace GetZoneStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartingZoneId)), startingZoneId));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMaxNumberOfZoneIds)), maxNumberOfZoneIds));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneStatusMaskFlag)), zoneStatusMaskFlag));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kZoneStatusMask)), zoneStatusMask));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStartingZoneId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startingZoneId));
+            break;
+        case to_underlying(Fields::kMaxNumberOfZoneIds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, maxNumberOfZoneIds));
+            break;
+        case to_underlying(Fields::kZoneStatusMaskFlag):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneStatusMaskFlag));
+            break;
+        case to_underlying(Fields::kZoneStatusMask):
+            ReturnErrorOnFailure(DataModel::Decode(reader, zoneStatusMask));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetZoneStatus.
+} // namespace Commands
+} // namespace IasAce
+namespace IasWd {
+
+namespace Commands {
+namespace StartWarning {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kWarningInfo)), warningInfo));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kWarningDuration)), warningDuration));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStrobeDutyCycle)), strobeDutyCycle));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStrobeLevel)), strobeLevel));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kWarningInfo):
+            ReturnErrorOnFailure(DataModel::Decode(reader, warningInfo));
+            break;
+        case to_underlying(Fields::kWarningDuration):
+            ReturnErrorOnFailure(DataModel::Decode(reader, warningDuration));
+            break;
+        case to_underlying(Fields::kStrobeDutyCycle):
+            ReturnErrorOnFailure(DataModel::Decode(reader, strobeDutyCycle));
+            break;
+        case to_underlying(Fields::kStrobeLevel):
+            ReturnErrorOnFailure(DataModel::Decode(reader, strobeLevel));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StartWarning.
+namespace Squawk {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSquawkInfo)), squawkInfo));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSquawkInfo):
+            ReturnErrorOnFailure(DataModel::Decode(reader, squawkInfo));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Squawk.
+} // namespace Commands
+} // namespace IasWd
+namespace WakeOnLan {
+
+namespace Commands {
+} // namespace Commands
+} // namespace WakeOnLan
+namespace TvChannel {
+namespace TvChannelInfo {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMajorNumber)), majorNumber));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMinorNumber)), minorNumber));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCallSign)), callSign));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAffiliateCallSign)), affiliateCallSign));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMajorNumber):
             ReturnErrorOnFailure(DataModel::Decode(reader, majorNumber));
             break;
-        case kMinorNumberFieldId:
+        case to_underlying(Fields::kMinorNumber):
             ReturnErrorOnFailure(DataModel::Decode(reader, minorNumber));
             break;
-        case kNameFieldId:
+        case to_underlying(Fields::kName):
             ReturnErrorOnFailure(DataModel::Decode(reader, name));
             break;
-        case kCallSignFieldId:
+        case to_underlying(Fields::kCallSign):
             ReturnErrorOnFailure(DataModel::Decode(reader, callSign));
             break;
-        case kAffiliateCallSignFieldId:
+        case to_underlying(Fields::kAffiliateCallSign):
             ReturnErrorOnFailure(DataModel::Decode(reader, affiliateCallSign));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1195,214 +12209,1455 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOperatorNameFieldId), operatorName));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLineupNameFieldId), lineupName));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPostalCodeFieldId), postalCode));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLineupInfoTypeFieldId), lineupInfoType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOperatorName)), operatorName));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLineupName)), lineupName));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPostalCode)), postalCode));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLineupInfoType)), lineupInfoType));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kOperatorNameFieldId:
+        case to_underlying(Fields::kOperatorName):
             ReturnErrorOnFailure(DataModel::Decode(reader, operatorName));
             break;
-        case kLineupNameFieldId:
+        case to_underlying(Fields::kLineupName):
             ReturnErrorOnFailure(DataModel::Decode(reader, lineupName));
             break;
-        case kPostalCodeFieldId:
+        case to_underlying(Fields::kPostalCode):
             ReturnErrorOnFailure(DataModel::Decode(reader, postalCode));
             break;
-        case kLineupInfoTypeFieldId:
+        case to_underlying(Fields::kLineupInfoType):
             ReturnErrorOnFailure(DataModel::Decode(reader, lineupInfoType));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace TvChannelLineupInfo
-} // namespace TvChannel
 
+namespace Commands {
+namespace ChangeChannel {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMatch)), match));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMatch):
+            ReturnErrorOnFailure(DataModel::Decode(reader, match));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ChangeChannel.
+namespace ChangeChannelResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kChannelMatch)), channelMatch));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kErrorType)), errorType));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kChannelMatch):
+            ReturnErrorOnFailure(DataModel::Decode(reader, channelMatch));
+            break;
+        case to_underlying(Fields::kErrorType):
+            ReturnErrorOnFailure(DataModel::Decode(reader, errorType));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ChangeChannelResponse.
+namespace ChangeChannelByNumber {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMajorNumber)), majorNumber));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMinorNumber)), minorNumber));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMajorNumber):
+            ReturnErrorOnFailure(DataModel::Decode(reader, majorNumber));
+            break;
+        case to_underlying(Fields::kMinorNumber):
+            ReturnErrorOnFailure(DataModel::Decode(reader, minorNumber));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ChangeChannelByNumber.
+namespace SkipChannel {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCount)), count));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, count));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SkipChannel.
+} // namespace Commands
+} // namespace TvChannel
 namespace TargetNavigator {
 namespace NavigateTargetTargetInfo {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIdentifierFieldId), identifier));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIdentifier)), identifier));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kIdentifierFieldId:
+        case to_underlying(Fields::kIdentifier):
             ReturnErrorOnFailure(DataModel::Decode(reader, identifier));
             break;
-        case kNameFieldId:
+        case to_underlying(Fields::kName):
             ReturnErrorOnFailure(DataModel::Decode(reader, name));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace NavigateTargetTargetInfo
-} // namespace TargetNavigator
 
+namespace Commands {
+namespace NavigateTarget {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTarget)), target));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTarget):
+            ReturnErrorOnFailure(DataModel::Decode(reader, target));
+            break;
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace NavigateTarget.
+namespace NavigateTargetResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace NavigateTargetResponse.
+} // namespace Commands
+} // namespace TargetNavigator
 namespace MediaPlayback {
 namespace MediaPlaybackPosition {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUpdatedAtFieldId), updatedAt));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPositionFieldId), position));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kUpdatedAt)), updatedAt));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPosition)), position));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kUpdatedAtFieldId:
+        case to_underlying(Fields::kUpdatedAt):
             ReturnErrorOnFailure(DataModel::Decode(reader, updatedAt));
             break;
-        case kPositionFieldId:
+        case to_underlying(Fields::kPosition):
             ReturnErrorOnFailure(DataModel::Decode(reader, position));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace MediaPlaybackPosition
-} // namespace MediaPlayback
 
+namespace Commands {
+namespace MediaPlay {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaPlay.
+namespace MediaPlayResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaPlayResponse.
+namespace MediaPause {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaPause.
+namespace MediaPauseResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaPauseResponse.
+namespace MediaStop {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaStop.
+namespace MediaStopResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaStopResponse.
+namespace MediaStartOver {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaStartOver.
+namespace MediaStartOverResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaStartOverResponse.
+namespace MediaPrevious {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaPrevious.
+namespace MediaPreviousResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaPreviousResponse.
+namespace MediaNext {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaNext.
+namespace MediaNextResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaNextResponse.
+namespace MediaRewind {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaRewind.
+namespace MediaRewindResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaRewindResponse.
+namespace MediaFastForward {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaFastForward.
+namespace MediaFastForwardResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaFastForwardResponse.
+namespace MediaSkipForward {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDeltaPositionMilliseconds)), deltaPositionMilliseconds));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kDeltaPositionMilliseconds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, deltaPositionMilliseconds));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaSkipForward.
+namespace MediaSkipForwardResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaSkipForwardResponse.
+namespace MediaSkipBackward {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDeltaPositionMilliseconds)), deltaPositionMilliseconds));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kDeltaPositionMilliseconds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, deltaPositionMilliseconds));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaSkipBackward.
+namespace MediaSkipBackwardResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaSkipBackwardResponse.
+namespace MediaSeek {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPosition)), position));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kPosition):
+            ReturnErrorOnFailure(DataModel::Decode(reader, position));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaSeek.
+namespace MediaSeekResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMediaPlaybackStatus)), mediaPlaybackStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMediaPlaybackStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, mediaPlaybackStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MediaSeekResponse.
+} // namespace Commands
+} // namespace MediaPlayback
 namespace MediaInput {
 namespace MediaInputInfo {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIndexFieldId), index));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kInputTypeFieldId), inputType));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDescriptionFieldId), description));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIndex)), index));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kInputType)), inputType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDescription)), description));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kIndexFieldId:
+        case to_underlying(Fields::kIndex):
             ReturnErrorOnFailure(DataModel::Decode(reader, index));
             break;
-        case kInputTypeFieldId:
+        case to_underlying(Fields::kInputType):
             ReturnErrorOnFailure(DataModel::Decode(reader, inputType));
             break;
-        case kNameFieldId:
+        case to_underlying(Fields::kName):
             ReturnErrorOnFailure(DataModel::Decode(reader, name));
             break;
-        case kDescriptionFieldId:
+        case to_underlying(Fields::kDescription):
             ReturnErrorOnFailure(DataModel::Decode(reader, description));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace MediaInputInfo
-} // namespace MediaInput
 
-namespace LowPower {
-} // namespace LowPower
-
-namespace KeypadInput {
-} // namespace KeypadInput
-
-namespace ContentLauncher {
-namespace ContentLaunchAdditionalInfo {
+namespace Commands {
+namespace SelectInput {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kValueFieldId), value));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIndex)), index));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kNameFieldId:
+        case to_underlying(Fields::kIndex):
+            ReturnErrorOnFailure(DataModel::Decode(reader, index));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SelectInput.
+namespace ShowInputStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ShowInputStatus.
+namespace HideInputStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace HideInputStatus.
+namespace RenameInput {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIndex)), index));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kIndex):
+            ReturnErrorOnFailure(DataModel::Decode(reader, index));
+            break;
+        case to_underlying(Fields::kName):
             ReturnErrorOnFailure(DataModel::Decode(reader, name));
             break;
-        case kValueFieldId:
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RenameInput.
+} // namespace Commands
+} // namespace MediaInput
+namespace LowPower {
+
+namespace Commands {
+namespace Sleep {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Sleep.
+} // namespace Commands
+} // namespace LowPower
+namespace KeypadInput {
+
+namespace Commands {
+namespace SendKey {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kKeyCode)), keyCode));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kKeyCode):
+            ReturnErrorOnFailure(DataModel::Decode(reader, keyCode));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SendKey.
+namespace SendKeyResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SendKeyResponse.
+} // namespace Commands
+} // namespace KeypadInput
+namespace ContentLauncher {
+namespace ContentLaunchAdditionalInfo {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kValue)), value));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, name));
+            break;
+        case to_underlying(Fields::kValue):
             ReturnErrorOnFailure(DataModel::Decode(reader, value));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1414,36 +13669,39 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTypeFieldId), type));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kValueFieldId), value));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kExternalIDListFieldId), externalIDList));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kType)), type));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kValue)), value));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kExternalIDList)), externalIDList));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kTypeFieldId:
+        case to_underlying(Fields::kType):
             ReturnErrorOnFailure(DataModel::Decode(reader, type));
             break;
-        case kValueFieldId:
+        case to_underlying(Fields::kValue):
             ReturnErrorOnFailure(DataModel::Decode(reader, value));
             break;
-        case kExternalIDListFieldId:
+        case to_underlying(Fields::kExternalIDList):
             ReturnErrorOnFailure(DataModel::Decode(reader, externalIDList));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1455,48 +13713,51 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProviderNameFieldId), providerName));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBackgroundFieldId), background));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLogoFieldId), logo));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProgressBarFieldId), progressBar));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSplashFieldId), splash));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kWaterMarkFieldId), waterMark));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kProviderName)), providerName));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kBackground)), background));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogo)), logo));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kProgressBar)), progressBar));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSplash)), splash));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kWaterMark)), waterMark));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kProviderNameFieldId:
+        case to_underlying(Fields::kProviderName):
             ReturnErrorOnFailure(DataModel::Decode(reader, providerName));
             break;
-        case kBackgroundFieldId:
+        case to_underlying(Fields::kBackground):
             ReturnErrorOnFailure(DataModel::Decode(reader, background));
             break;
-        case kLogoFieldId:
+        case to_underlying(Fields::kLogo):
             ReturnErrorOnFailure(DataModel::Decode(reader, logo));
             break;
-        case kProgressBarFieldId:
+        case to_underlying(Fields::kProgressBar):
             ReturnErrorOnFailure(DataModel::Decode(reader, progressBar));
             break;
-        case kSplashFieldId:
+        case to_underlying(Fields::kSplash):
             ReturnErrorOnFailure(DataModel::Decode(reader, splash));
             break;
-        case kWaterMarkFieldId:
+        case to_underlying(Fields::kWaterMark):
             ReturnErrorOnFailure(DataModel::Decode(reader, waterMark));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1508,36 +13769,39 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kWidthFieldId), width));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kHeightFieldId), height));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMetricFieldId), metric));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kWidth)), width));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kHeight)), height));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMetric)), metric));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kWidthFieldId:
+        case to_underlying(Fields::kWidth):
             ReturnErrorOnFailure(DataModel::Decode(reader, width));
             break;
-        case kHeightFieldId:
+        case to_underlying(Fields::kHeight):
             ReturnErrorOnFailure(DataModel::Decode(reader, height));
             break;
-        case kMetricFieldId:
+        case to_underlying(Fields::kMetric):
             ReturnErrorOnFailure(DataModel::Decode(reader, metric));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1549,178 +13813,660 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kImageUrlFieldId), imageUrl));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorFieldId), color));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSizeFieldId), size));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kImageUrl)), imageUrl));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kColor)), color));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSize)), size));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kImageUrlFieldId:
+        case to_underlying(Fields::kImageUrl):
             ReturnErrorOnFailure(DataModel::Decode(reader, imageUrl));
             break;
-        case kColorFieldId:
+        case to_underlying(Fields::kColor):
             ReturnErrorOnFailure(DataModel::Decode(reader, color));
             break;
-        case kSizeFieldId:
+        case to_underlying(Fields::kSize):
             ReturnErrorOnFailure(DataModel::Decode(reader, size));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace ContentLaunchStyleInformation
-} // namespace ContentLauncher
 
+namespace Commands {
+namespace LaunchContent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAutoPlay)), autoPlay));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAutoPlay):
+            ReturnErrorOnFailure(DataModel::Decode(reader, autoPlay));
+            break;
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LaunchContent.
+namespace LaunchContentResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kContentLaunchStatus)), contentLaunchStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        case to_underlying(Fields::kContentLaunchStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, contentLaunchStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LaunchContentResponse.
+namespace LaunchURL {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kContentURL)), contentURL));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDisplayString)), displayString));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kContentURL):
+            ReturnErrorOnFailure(DataModel::Decode(reader, contentURL));
+            break;
+        case to_underlying(Fields::kDisplayString):
+            ReturnErrorOnFailure(DataModel::Decode(reader, displayString));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LaunchURL.
+namespace LaunchURLResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kContentLaunchStatus)), contentLaunchStatus));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        case to_underlying(Fields::kContentLaunchStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, contentLaunchStatus));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LaunchURLResponse.
+} // namespace Commands
+} // namespace ContentLauncher
 namespace AudioOutput {
 namespace AudioOutputInfo {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIndexFieldId), index));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOutputTypeFieldId), outputType));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIndex)), index));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOutputType)), outputType));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kIndexFieldId:
+        case to_underlying(Fields::kIndex):
             ReturnErrorOnFailure(DataModel::Decode(reader, index));
             break;
-        case kOutputTypeFieldId:
+        case to_underlying(Fields::kOutputType):
             ReturnErrorOnFailure(DataModel::Decode(reader, outputType));
             break;
-        case kNameFieldId:
+        case to_underlying(Fields::kName):
             ReturnErrorOnFailure(DataModel::Decode(reader, name));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace AudioOutputInfo
-} // namespace AudioOutput
 
+namespace Commands {
+namespace SelectOutput {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIndex)), index));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kIndex):
+            ReturnErrorOnFailure(DataModel::Decode(reader, index));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace SelectOutput.
+namespace RenameOutput {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIndex)), index));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kName)), name));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kIndex):
+            ReturnErrorOnFailure(DataModel::Decode(reader, index));
+            break;
+        case to_underlying(Fields::kName):
+            ReturnErrorOnFailure(DataModel::Decode(reader, name));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace RenameOutput.
+} // namespace Commands
+} // namespace AudioOutput
 namespace ApplicationLauncher {
 namespace ApplicationLauncherApp {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCatalogVendorIdFieldId), catalogVendorId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kApplicationIdFieldId), applicationId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCatalogVendorId)), catalogVendorId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kApplicationId)), applicationId));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kCatalogVendorIdFieldId:
+        case to_underlying(Fields::kCatalogVendorId):
             ReturnErrorOnFailure(DataModel::Decode(reader, catalogVendorId));
             break;
-        case kApplicationIdFieldId:
+        case to_underlying(Fields::kApplicationId):
             ReturnErrorOnFailure(DataModel::Decode(reader, applicationId));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace ApplicationLauncherApp
-} // namespace ApplicationLauncher
 
-namespace ApplicationBasic {
-} // namespace ApplicationBasic
-
-namespace AccountLogin {
-} // namespace AccountLogin
-
-namespace TestCluster {
-namespace SimpleStruct {
+namespace Commands {
+namespace LaunchApp {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDFieldId), d));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEFieldId), e));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kCatalogVendorId)), catalogVendorId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kApplicationId)), applicationId));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kAFieldId:
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        case to_underlying(Fields::kCatalogVendorId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, catalogVendorId));
+            break;
+        case to_underlying(Fields::kApplicationId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, applicationId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LaunchApp.
+namespace LaunchAppResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kData)), data));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kData):
+            ReturnErrorOnFailure(DataModel::Decode(reader, data));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LaunchAppResponse.
+} // namespace Commands
+} // namespace ApplicationLauncher
+namespace ApplicationBasic {
+
+namespace Commands {
+namespace ChangeStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace ChangeStatus.
+} // namespace Commands
+} // namespace ApplicationBasic
+namespace AccountLogin {
+
+namespace Commands {
+namespace GetSetupPIN {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTempAccountIdentifier)), tempAccountIdentifier));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTempAccountIdentifier):
+            ReturnErrorOnFailure(DataModel::Decode(reader, tempAccountIdentifier));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetSetupPIN.
+namespace GetSetupPINResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSetupPIN)), setupPIN));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kSetupPIN):
+            ReturnErrorOnFailure(DataModel::Decode(reader, setupPIN));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetSetupPINResponse.
+namespace Login {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTempAccountIdentifier)), tempAccountIdentifier));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kSetupPIN)), setupPIN));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTempAccountIdentifier):
+            ReturnErrorOnFailure(DataModel::Decode(reader, tempAccountIdentifier));
+            break;
+        case to_underlying(Fields::kSetupPIN):
+            ReturnErrorOnFailure(DataModel::Decode(reader, setupPIN));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Login.
+} // namespace Commands
+} // namespace AccountLogin
+namespace TestCluster {
+namespace SimpleStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kA)), a));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kB)), b));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kC)), c));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kD)), d));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kE)), e));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kA):
             ReturnErrorOnFailure(DataModel::Decode(reader, a));
             break;
-        case kBFieldId:
+        case to_underlying(Fields::kB):
             ReturnErrorOnFailure(DataModel::Decode(reader, b));
             break;
-        case kCFieldId:
+        case to_underlying(Fields::kC):
             ReturnErrorOnFailure(DataModel::Decode(reader, c));
             break;
-        case kDFieldId:
+        case to_underlying(Fields::kD):
             ReturnErrorOnFailure(DataModel::Decode(reader, d));
             break;
-        case kEFieldId:
+        case to_underlying(Fields::kE):
             ReturnErrorOnFailure(DataModel::Decode(reader, e));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1732,36 +14478,39 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kA)), a));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kB)), b));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kC)), c));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kAFieldId:
+        case to_underlying(Fields::kA):
             ReturnErrorOnFailure(DataModel::Decode(reader, a));
             break;
-        case kBFieldId:
+        case to_underlying(Fields::kB):
             ReturnErrorOnFailure(DataModel::Decode(reader, b));
             break;
-        case kCFieldId:
+        case to_underlying(Fields::kC):
             ReturnErrorOnFailure(DataModel::Decode(reader, c));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1773,52 +14522,55 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDFieldId), d));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEFieldId), e));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFFieldId), f));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGFieldId), g));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kA)), a));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kB)), b));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kC)), c));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kD)), d));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kE)), e));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kF)), f));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kG)), g));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kAFieldId:
+        case to_underlying(Fields::kA):
             ReturnErrorOnFailure(DataModel::Decode(reader, a));
             break;
-        case kBFieldId:
+        case to_underlying(Fields::kB):
             ReturnErrorOnFailure(DataModel::Decode(reader, b));
             break;
-        case kCFieldId:
+        case to_underlying(Fields::kC):
             ReturnErrorOnFailure(DataModel::Decode(reader, c));
             break;
-        case kDFieldId:
+        case to_underlying(Fields::kD):
             ReturnErrorOnFailure(DataModel::Decode(reader, d));
             break;
-        case kEFieldId:
+        case to_underlying(Fields::kE):
             ReturnErrorOnFailure(DataModel::Decode(reader, e));
             break;
-        case kFFieldId:
+        case to_underlying(Fields::kF):
             ReturnErrorOnFailure(DataModel::Decode(reader, f));
             break;
-        case kGFieldId:
+        case to_underlying(Fields::kG):
             ReturnErrorOnFailure(DataModel::Decode(reader, g));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1830,28 +14582,31 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kA)), a));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kAFieldId:
+        case to_underlying(Fields::kA):
             ReturnErrorOnFailure(DataModel::Decode(reader, a));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1863,105 +14618,1496 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOperationalCertFieldId), operationalCert));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kFabricIndex)), fabricIndex));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOperationalCert)), operationalCert));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kFabricIndexFieldId:
+        case to_underlying(Fields::kFabricIndex):
             ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex));
             break;
-        case kOperationalCertFieldId:
+        case to_underlying(Fields::kOperationalCert):
             ReturnErrorOnFailure(DataModel::Decode(reader, operationalCert));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace TestListStructOctet
-} // namespace TestCluster
 
-namespace Messaging {
-} // namespace Messaging
-
-namespace ApplianceIdentification {
-} // namespace ApplianceIdentification
-
-namespace MeterIdentification {
-} // namespace MeterIdentification
-
-namespace ApplianceEventsAndAlert {
-} // namespace ApplianceEventsAndAlert
-
-namespace ApplianceStatistics {
-} // namespace ApplianceStatistics
-
-namespace ElectricalMeasurement {
-} // namespace ElectricalMeasurement
-
-namespace Binding {
-} // namespace Binding
-
-namespace GroupKeyManagement {
-namespace GroupKey {
+namespace Commands {
+namespace Test {
 CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kVendorIdFieldId), vendorId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupKeyIndexFieldId), groupKeyIndex));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupKeyRootFieldId), groupKeyRoot));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupKeyEpochStartTimeFieldId), groupKeyEpochStartTime));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupKeySecurityPolicyFieldId), groupKeySecurityPolicy));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kVendorIdFieldId:
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Test.
+namespace TestSpecificResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kReturnValue)), returnValue));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kReturnValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, returnValue));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestSpecificResponse.
+namespace TestNotHandled {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestNotHandled.
+namespace TestAddArgumentsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kReturnValue)), returnValue));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kReturnValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, returnValue));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestAddArgumentsResponse.
+namespace TestSpecific {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestSpecific.
+namespace TestSimpleArgumentResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kReturnValue)), returnValue));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kReturnValue):
+            ReturnErrorOnFailure(DataModel::Decode(reader, returnValue));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestSimpleArgumentResponse.
+namespace TestUnknownCommand {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestUnknownCommand.
+namespace TestStructArrayArgumentResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg1)), arg1));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg2)), arg2));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg3)), arg3));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg4)), arg4));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg5)), arg5));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg6)), arg6));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kArg1):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg1));
+            break;
+        case to_underlying(Fields::kArg2):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg2));
+            break;
+        case to_underlying(Fields::kArg3):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg3));
+            break;
+        case to_underlying(Fields::kArg4):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg4));
+            break;
+        case to_underlying(Fields::kArg5):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg5));
+            break;
+        case to_underlying(Fields::kArg6):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg6));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestStructArrayArgumentResponse.
+namespace TestAddArguments {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg1)), arg1));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg2)), arg2));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kArg1):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg1));
+            break;
+        case to_underlying(Fields::kArg2):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg2));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestAddArguments.
+namespace TestSimpleArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg1)), arg1));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kArg1):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg1));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestSimpleArgumentRequest.
+namespace TestStructArrayArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg1)), arg1));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg2)), arg2));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg3)), arg3));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg4)), arg4));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg5)), arg5));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg6)), arg6));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kArg1):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg1));
+            break;
+        case to_underlying(Fields::kArg2):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg2));
+            break;
+        case to_underlying(Fields::kArg3):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg3));
+            break;
+        case to_underlying(Fields::kArg4):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg4));
+            break;
+        case to_underlying(Fields::kArg5):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg5));
+            break;
+        case to_underlying(Fields::kArg6):
+            ReturnErrorOnFailure(DataModel::Decode(reader, arg6));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace TestStructArrayArgumentRequest.
+} // namespace Commands
+} // namespace TestCluster
+namespace Messaging {
+
+namespace Commands {
+namespace DisplayMessage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageId)), messageId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageControl)), messageControl));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartTime)), startTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDurationInMinutes)), durationInMinutes));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessage)), message));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionalExtendedMessageControl)),
+                                           optionalExtendedMessageControl));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMessageId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageId));
+            break;
+        case to_underlying(Fields::kMessageControl):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageControl));
+            break;
+        case to_underlying(Fields::kStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startTime));
+            break;
+        case to_underlying(Fields::kDurationInMinutes):
+            ReturnErrorOnFailure(DataModel::Decode(reader, durationInMinutes));
+            break;
+        case to_underlying(Fields::kMessage):
+            ReturnErrorOnFailure(DataModel::Decode(reader, message));
+            break;
+        case to_underlying(Fields::kOptionalExtendedMessageControl):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionalExtendedMessageControl));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace DisplayMessage.
+namespace GetLastMessage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetLastMessage.
+namespace CancelMessage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageId)), messageId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageControl)), messageControl));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMessageId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageId));
+            break;
+        case to_underlying(Fields::kMessageControl):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageControl));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CancelMessage.
+namespace MessageConfirmation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageId)), messageId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kConfirmationTime)), confirmationTime));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageConfirmationControl)), messageConfirmationControl));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageResponse)), messageResponse));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMessageId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageId));
+            break;
+        case to_underlying(Fields::kConfirmationTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, confirmationTime));
+            break;
+        case to_underlying(Fields::kMessageConfirmationControl):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageConfirmationControl));
+            break;
+        case to_underlying(Fields::kMessageResponse):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageResponse));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace MessageConfirmation.
+namespace DisplayProtectedMessage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageId)), messageId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessageControl)), messageControl));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartTime)), startTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kDurationInMinutes)), durationInMinutes));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMessage)), message));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kOptionalExtendedMessageControl)),
+                                           optionalExtendedMessageControl));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kMessageId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageId));
+            break;
+        case to_underlying(Fields::kMessageControl):
+            ReturnErrorOnFailure(DataModel::Decode(reader, messageControl));
+            break;
+        case to_underlying(Fields::kStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startTime));
+            break;
+        case to_underlying(Fields::kDurationInMinutes):
+            ReturnErrorOnFailure(DataModel::Decode(reader, durationInMinutes));
+            break;
+        case to_underlying(Fields::kMessage):
+            ReturnErrorOnFailure(DataModel::Decode(reader, message));
+            break;
+        case to_underlying(Fields::kOptionalExtendedMessageControl):
+            ReturnErrorOnFailure(DataModel::Decode(reader, optionalExtendedMessageControl));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace DisplayProtectedMessage.
+namespace GetMessageCancellation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEarliestImplementationTime)), earliestImplementationTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kEarliestImplementationTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, earliestImplementationTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetMessageCancellation.
+namespace CancelAllMessages {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kImplementationDateTime)), implementationDateTime));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kImplementationDateTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, implementationDateTime));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CancelAllMessages.
+} // namespace Commands
+} // namespace Messaging
+namespace ApplianceIdentification {
+
+namespace Commands {
+} // namespace Commands
+} // namespace ApplianceIdentification
+namespace MeterIdentification {
+
+namespace Commands {
+} // namespace Commands
+} // namespace MeterIdentification
+namespace ApplianceEventsAndAlert {
+
+namespace Commands {
+namespace GetAlerts {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetAlerts.
+namespace GetAlertsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAlertsCount)), alertsCount));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAlertsCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, alertsCount));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetAlertsResponse.
+namespace AlertsNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAlertsCount)), alertsCount));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAlertsCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, alertsCount));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace AlertsNotification.
+namespace EventsNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEventHeader)), eventHeader));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEventId)), eventId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kEventHeader):
+            ReturnErrorOnFailure(DataModel::Decode(reader, eventHeader));
+            break;
+        case to_underlying(Fields::kEventId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, eventId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace EventsNotification.
+} // namespace Commands
+} // namespace ApplianceEventsAndAlert
+namespace ApplianceStatistics {
+
+namespace Commands {
+namespace LogNotification {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeStamp)), timeStamp));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogId)), logId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogLength)), logLength));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogPayload)), logPayload));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTimeStamp):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeStamp));
+            break;
+        case to_underlying(Fields::kLogId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logId));
+            break;
+        case to_underlying(Fields::kLogLength):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logLength));
+            break;
+        case to_underlying(Fields::kLogPayload):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logPayload));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LogNotification.
+namespace LogRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogId)), logId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLogId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LogRequest.
+namespace LogResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kTimeStamp)), timeStamp));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogId)), logId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogLength)), logLength));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogPayload)), logPayload));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kTimeStamp):
+            ReturnErrorOnFailure(DataModel::Decode(reader, timeStamp));
+            break;
+        case to_underlying(Fields::kLogId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logId));
+            break;
+        case to_underlying(Fields::kLogLength):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logLength));
+            break;
+        case to_underlying(Fields::kLogPayload):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logPayload));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LogResponse.
+namespace LogQueueRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LogQueueRequest.
+namespace LogQueueResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogQueueSize)), logQueueSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogIds)), logIds));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLogQueueSize):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logQueueSize));
+            break;
+        case to_underlying(Fields::kLogIds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logIds));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace LogQueueResponse.
+namespace StatisticsAvailable {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogQueueSize)), logQueueSize));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kLogIds)), logIds));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kLogQueueSize):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logQueueSize));
+            break;
+        case to_underlying(Fields::kLogIds):
+            ReturnErrorOnFailure(DataModel::Decode(reader, logIds));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace StatisticsAvailable.
+} // namespace Commands
+} // namespace ApplianceStatistics
+namespace ElectricalMeasurement {
+
+namespace Commands {
+namespace GetProfileInfoResponseCommand {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kProfileCount)), profileCount));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kProfileIntervalPeriod)), profileIntervalPeriod));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kMaxNumberOfIntervals)), maxNumberOfIntervals));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kListOfAttributes)), listOfAttributes));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kProfileCount):
+            ReturnErrorOnFailure(DataModel::Decode(reader, profileCount));
+            break;
+        case to_underlying(Fields::kProfileIntervalPeriod):
+            ReturnErrorOnFailure(DataModel::Decode(reader, profileIntervalPeriod));
+            break;
+        case to_underlying(Fields::kMaxNumberOfIntervals):
+            ReturnErrorOnFailure(DataModel::Decode(reader, maxNumberOfIntervals));
+            break;
+        case to_underlying(Fields::kListOfAttributes):
+            ReturnErrorOnFailure(DataModel::Decode(reader, listOfAttributes));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetProfileInfoResponseCommand.
+namespace GetProfileInfoCommand {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetProfileInfoCommand.
+namespace GetMeasurementProfileResponseCommand {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartTime)), startTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStatus)), status));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kProfileIntervalPeriod)), profileIntervalPeriod));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumberOfIntervalsDelivered)), numberOfIntervalsDelivered));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAttributeId)), attributeId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kIntervals)), intervals));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startTime));
+            break;
+        case to_underlying(Fields::kStatus):
+            ReturnErrorOnFailure(DataModel::Decode(reader, status));
+            break;
+        case to_underlying(Fields::kProfileIntervalPeriod):
+            ReturnErrorOnFailure(DataModel::Decode(reader, profileIntervalPeriod));
+            break;
+        case to_underlying(Fields::kNumberOfIntervalsDelivered):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numberOfIntervalsDelivered));
+            break;
+        case to_underlying(Fields::kAttributeId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, attributeId));
+            break;
+        case to_underlying(Fields::kIntervals):
+            ReturnErrorOnFailure(DataModel::Decode(reader, intervals));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetMeasurementProfileResponseCommand.
+namespace GetMeasurementProfileCommand {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kAttributeId)), attributeId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kStartTime)), startTime));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNumberOfIntervals)), numberOfIntervals));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kAttributeId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, attributeId));
+            break;
+        case to_underlying(Fields::kStartTime):
+            ReturnErrorOnFailure(DataModel::Decode(reader, startTime));
+            break;
+        case to_underlying(Fields::kNumberOfIntervals):
+            ReturnErrorOnFailure(DataModel::Decode(reader, numberOfIntervals));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace GetMeasurementProfileCommand.
+} // namespace Commands
+} // namespace ElectricalMeasurement
+namespace Binding {
+
+namespace Commands {
+namespace Bind {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNodeId)), nodeId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEndpointId)), endpointId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kClusterId)), clusterId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNodeId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, nodeId));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kEndpointId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, endpointId));
+            break;
+        case to_underlying(Fields::kClusterId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, clusterId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Bind.
+namespace Unbind {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kNodeId)), nodeId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupId)), groupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kEndpointId)), endpointId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kClusterId)), clusterId));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kNodeId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, nodeId));
+            break;
+        case to_underlying(Fields::kGroupId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, groupId));
+            break;
+        case to_underlying(Fields::kEndpointId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, endpointId));
+            break;
+        case to_underlying(Fields::kClusterId):
+            ReturnErrorOnFailure(DataModel::Decode(reader, clusterId));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace Unbind.
+} // namespace Commands
+} // namespace Binding
+namespace GroupKeyManagement {
+namespace GroupKey {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kVendorId)), vendorId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupKeyIndex)), groupKeyIndex));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupKeyRoot)), groupKeyRoot));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupKeyEpochStartTime)), groupKeyEpochStartTime));
+    ReturnErrorOnFailure(
+        DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupKeySecurityPolicy)), groupKeySecurityPolicy));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kVendorId):
             ReturnErrorOnFailure(DataModel::Decode(reader, vendorId));
             break;
-        case kGroupKeyIndexFieldId:
+        case to_underlying(Fields::kGroupKeyIndex):
             ReturnErrorOnFailure(DataModel::Decode(reader, groupKeyIndex));
             break;
-        case kGroupKeyRootFieldId:
+        case to_underlying(Fields::kGroupKeyRoot):
             ReturnErrorOnFailure(DataModel::Decode(reader, groupKeyRoot));
             break;
-        case kGroupKeyEpochStartTimeFieldId:
+        case to_underlying(Fields::kGroupKeyEpochStartTime):
             ReturnErrorOnFailure(DataModel::Decode(reader, groupKeyEpochStartTime));
             break;
-        case kGroupKeySecurityPolicyFieldId:
+        case to_underlying(Fields::kGroupKeySecurityPolicy):
             ReturnErrorOnFailure(DataModel::Decode(reader, groupKeySecurityPolicy));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
@@ -1973,48 +16119,128 @@
 {
     TLV::TLVType outer;
     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kVendorIdFieldId), vendorId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kVendorGroupIdFieldId), vendorGroupId));
-    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupKeySetIndexFieldId), groupKeySetIndex));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kVendorId)), vendorId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kVendorGroupId)), vendorGroupId));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kGroupKeySetIndex)), groupKeySetIndex));
     ReturnErrorOnFailure(writer.EndContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
 {
-    CHIP_ERROR err;
+    CHIP_ERROR err = CHIP_NO_ERROR;
     TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
     err = reader.EnterContainer(outer);
     ReturnErrorOnFailure(err);
     while ((err = reader.Next()) == CHIP_NO_ERROR)
     {
-        switch (chip::TLV::TagNumFromTag(reader.GetTag()))
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
         {
-        case kVendorIdFieldId:
+        case to_underlying(Fields::kVendorId):
             ReturnErrorOnFailure(DataModel::Decode(reader, vendorId));
             break;
-        case kVendorGroupIdFieldId:
+        case to_underlying(Fields::kVendorGroupId):
             ReturnErrorOnFailure(DataModel::Decode(reader, vendorGroupId));
             break;
-        case kGroupKeySetIndexFieldId:
+        case to_underlying(Fields::kGroupKeySetIndex):
             ReturnErrorOnFailure(DataModel::Decode(reader, groupKeySetIndex));
             break;
         default:
             break;
         }
     }
+
     VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     ReturnErrorOnFailure(reader.ExitContainer(outer));
     return CHIP_NO_ERROR;
 }
 
 } // namespace GroupState
+
+namespace Commands {
+} // namespace Commands
 } // namespace GroupKeyManagement
-
 namespace SampleMfgSpecificCluster {
-} // namespace SampleMfgSpecificCluster
 
+namespace Commands {
+namespace CommandOne {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArgOne)), argOne));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kArgOne):
+            ReturnErrorOnFailure(DataModel::Decode(reader, argOne));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CommandOne.
+} // namespace Commands
+} // namespace SampleMfgSpecificCluster
 namespace SampleMfgSpecificCluster2 {
+
+namespace Commands {
+namespace CommandTwo {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const
+{
+    TLV::TLVType outer;
+    ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+    ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArgOne)), argOne));
+    ReturnErrorOnFailure(writer.EndContainer(outer));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    TLV::TLVType outer;
+    VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+    err = reader.EnterContainer(outer);
+    ReturnErrorOnFailure(err);
+    while ((err = reader.Next()) == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
+        switch (TLV::TagNumFromTag(reader.GetTag()))
+        {
+        case to_underlying(Fields::kArgOne):
+            ReturnErrorOnFailure(DataModel::Decode(reader, argOne));
+            break;
+        default:
+            break;
+        }
+    }
+
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    ReturnErrorOnFailure(reader.ExitContainer(outer));
+    return CHIP_NO_ERROR;
+}
+} // namespace CommandTwo.
+} // namespace Commands
 } // namespace SampleMfgSpecificCluster2
 
 } // namespace Clusters
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 d024698..a311c58 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
@@ -19,11 +19,14 @@
 
 #pragma once
 
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app-common/zap-generated/ids/Commands.h>
 #include <app/data-model/DecodableList.h>
 #include <app/data-model/Decode.h>
 #include <app/data-model/Encode.h>
 #include <app/data-model/List.h>
 #include <app/util/basic-types.h>
+#include <protocols/interaction_model/Constants.h>
 
 namespace chip {
 namespace app {
@@ -64,166 +67,440 @@
 
 namespace Commands {
 namespace Identify {
+enum class Fields
+{
+    kIdentifyTime = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Identify::Id; }
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
+
+    uint16_t identifyTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Identify
+public:
+    static constexpr CommandId GetCommandId() { return Identify::Id; }
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
 
+    uint16_t identifyTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Identify
 namespace IdentifyQueryResponse {
+enum class Fields
+{
+    kTimeout = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return IdentifyQueryResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
+
+    uint16_t timeout;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace IdentifyQueryResponse
+public:
+    static constexpr CommandId GetCommandId() { return IdentifyQueryResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
 
+    uint16_t timeout;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace IdentifyQueryResponse
 namespace IdentifyQuery {
+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 IdentifyQuery::Id; }
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace IdentifyQuery
+public:
+    static constexpr CommandId GetCommandId() { return IdentifyQuery::Id; }
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace IdentifyQuery
 namespace TriggerEffect {
+enum class Fields
+{
+    kEffectIdentifier = 0,
+    kEffectVariant    = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return TriggerEffect::Id; }
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
+
+    IdentifyEffectIdentifier effectIdentifier;
+    IdentifyEffectVariant effectVariant;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace TriggerEffect
+public:
+    static constexpr CommandId GetCommandId() { return TriggerEffect::Id; }
+    static constexpr ClusterId GetClusterId() { return Identify::Id; }
 
+    IdentifyEffectIdentifier effectIdentifier;
+    IdentifyEffectVariant effectVariant;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TriggerEffect
 } // namespace Commands
 } // namespace Identify
 namespace Groups {
 
 namespace Commands {
 namespace AddGroup {
-struct Type
+enum class Fields
 {
-};
-
-struct DecodableType
-{
-};
-} // namespace AddGroup
-
-namespace AddGroupResponse {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace AddGroupResponse
-
-namespace ViewGroup {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace ViewGroup
-
-namespace ViewGroupResponse {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace ViewGroupResponse
-
-namespace GetGroupMembership {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace GetGroupMembership
-
-namespace GetGroupMembershipResponse {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace GetGroupMembershipResponse
-
-namespace RemoveGroup {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace RemoveGroup
-
-namespace RemoveGroupResponse {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace RemoveGroupResponse
-
-namespace RemoveAllGroups {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace RemoveAllGroups
-
-namespace AddGroupIfIdentifying {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace AddGroupIfIdentifying
-
-} // namespace Commands
-} // namespace Groups
-namespace Scenes {
-
-namespace SceneExtensionFieldSet {
-enum FieldId
-{
-    kClusterIdFieldId = 0,
-    kLengthFieldId    = 1,
-    kValueFieldId     = 2,
+    kGroupId   = 0,
+    kGroupName = 1,
 };
 
 struct Type
 {
 public:
-    uint32_t clusterId;
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddGroup::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint16_t groupId;
+    Span<const char> groupName;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return AddGroup::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint16_t groupId;
+    Span<const char> groupName;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddGroup
+namespace AddGroupResponse {
+enum class Fields
+{
+    kStatus  = 0,
+    kGroupId = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddGroupResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return AddGroupResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddGroupResponse
+namespace ViewGroup {
+enum class Fields
+{
+    kGroupId = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ViewGroup::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint16_t groupId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ViewGroup::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint16_t groupId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ViewGroup
+namespace ViewGroupResponse {
+enum class Fields
+{
+    kStatus    = 0,
+    kGroupId   = 1,
+    kGroupName = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ViewGroupResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    Span<const char> groupName;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ViewGroupResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    Span<const char> groupName;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ViewGroupResponse
+namespace GetGroupMembership {
+enum class Fields
+{
+    kGroupCount = 0,
+    kGroupList  = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetGroupMembership::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t groupCount;
+    DataModel::List<uint16_t> groupList;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetGroupMembership::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t groupCount;
+    DataModel::DecodableList<uint16_t> groupList;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetGroupMembership
+namespace GetGroupMembershipResponse {
+enum class Fields
+{
+    kCapacity   = 0,
+    kGroupCount = 1,
+    kGroupList  = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetGroupMembershipResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t capacity;
+    uint8_t groupCount;
+    DataModel::List<uint16_t> groupList;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return GetGroupMembershipResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t capacity;
+    uint8_t groupCount;
+    DataModel::DecodableList<uint16_t> groupList;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetGroupMembershipResponse
+namespace RemoveGroup {
+enum class Fields
+{
+    kGroupId = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RemoveGroup::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint16_t groupId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return RemoveGroup::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint16_t groupId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveGroup
+namespace RemoveGroupResponse {
+enum class Fields
+{
+    kStatus  = 0,
+    kGroupId = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RemoveGroupResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return RemoveGroupResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveGroupResponse
+namespace RemoveAllGroups {
+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 RemoveAllGroups::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return RemoveAllGroups::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveAllGroups
+namespace AddGroupIfIdentifying {
+enum class Fields
+{
+    kGroupId   = 0,
+    kGroupName = 1,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddGroupIfIdentifying::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint16_t groupId;
+    Span<const char> groupName;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return AddGroupIfIdentifying::Id; }
+    static constexpr ClusterId GetClusterId() { return Groups::Id; }
+
+    uint16_t groupId;
+    Span<const char> groupName;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddGroupIfIdentifying
+} // namespace Commands
+} // namespace Groups
+namespace Scenes {
+
+namespace SceneExtensionFieldSet {
+enum class Fields
+{
+    kClusterId = 0,
+    kLength    = 1,
+    kValue     = 2,
+};
+
+struct Type
+{
+public:
+    chip::ClusterId clusterId;
     uint8_t length;
     uint8_t value;
 
@@ -237,195 +514,666 @@
 
 namespace Commands {
 namespace AddScene {
+enum class Fields
+{
+    kGroupId            = 0,
+    kSceneId            = 1,
+    kTransitionTime     = 2,
+    kSceneName          = 3,
+    kExtensionFieldSets = 4,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    Span<const char> sceneName;
+    DataModel::List<SceneExtensionFieldSet::Type> extensionFieldSets;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AddScene
+public:
+    static constexpr CommandId GetCommandId() { return AddScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    Span<const char> sceneName;
+    DataModel::DecodableList<SceneExtensionFieldSet::DecodableType> extensionFieldSets;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddScene
 namespace AddSceneResponse {
+enum class Fields
+{
+    kStatus  = 0,
+    kGroupId = 1,
+    kSceneId = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AddSceneResponse
+public:
+    static constexpr CommandId GetCommandId() { return AddSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddSceneResponse
 namespace ViewScene {
+enum class Fields
+{
+    kGroupId = 0,
+    kSceneId = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ViewScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+    uint8_t sceneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ViewScene
+public:
+    static constexpr CommandId GetCommandId() { return ViewScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    uint8_t sceneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ViewScene
 namespace ViewSceneResponse {
+enum class Fields
+{
+    kStatus             = 0,
+    kGroupId            = 1,
+    kSceneId            = 2,
+    kTransitionTime     = 3,
+    kSceneName          = 4,
+    kExtensionFieldSets = 5,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ViewSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    Span<const char> sceneName;
+    DataModel::List<SceneExtensionFieldSet::Type> extensionFieldSets;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ViewSceneResponse
+public:
+    static constexpr CommandId GetCommandId() { return ViewSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    Span<const char> sceneName;
+    DataModel::DecodableList<SceneExtensionFieldSet::DecodableType> extensionFieldSets;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ViewSceneResponse
 namespace RemoveScene {
+enum class Fields
+{
+    kGroupId = 0,
+    kSceneId = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RemoveScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+    uint8_t sceneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RemoveScene
+public:
+    static constexpr CommandId GetCommandId() { return RemoveScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    uint8_t sceneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveScene
 namespace RemoveSceneResponse {
+enum class Fields
+{
+    kStatus  = 0,
+    kGroupId = 1,
+    kSceneId = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RemoveSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RemoveSceneResponse
+public:
+    static constexpr CommandId GetCommandId() { return RemoveSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveSceneResponse
 namespace RemoveAllScenes {
+enum class Fields
+{
+    kGroupId = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RemoveAllScenes::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RemoveAllScenes
+public:
+    static constexpr CommandId GetCommandId() { return RemoveAllScenes::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveAllScenes
 namespace RemoveAllScenesResponse {
+enum class Fields
+{
+    kStatus  = 0,
+    kGroupId = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RemoveAllScenesResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RemoveAllScenesResponse
+public:
+    static constexpr CommandId GetCommandId() { return RemoveAllScenesResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint16_t groupId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveAllScenesResponse
 namespace StoreScene {
+enum class Fields
+{
+    kGroupId = 0,
+    kSceneId = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return StoreScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+    uint8_t sceneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StoreScene
+public:
+    static constexpr CommandId GetCommandId() { return StoreScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    uint8_t sceneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StoreScene
 namespace StoreSceneResponse {
+enum class Fields
+{
+    kStatus  = 0,
+    kGroupId = 1,
+    kSceneId = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return StoreSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StoreSceneResponse
+public:
+    static constexpr CommandId GetCommandId() { return StoreSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StoreSceneResponse
 namespace RecallScene {
+enum class Fields
+{
+    kGroupId        = 0,
+    kSceneId        = 1,
+    kTransitionTime = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RecallScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RecallScene
+public:
+    static constexpr CommandId GetCommandId() { return RecallScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RecallScene
 namespace GetSceneMembership {
+enum class Fields
+{
+    kGroupId = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetSceneMembership::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetSceneMembership
+public:
+    static constexpr CommandId GetCommandId() { return GetSceneMembership::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetSceneMembership
 namespace GetSceneMembershipResponse {
+enum class Fields
+{
+    kStatus     = 0,
+    kCapacity   = 1,
+    kGroupId    = 2,
+    kSceneCount = 3,
+    kSceneList  = 4,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetSceneMembershipResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint8_t capacity;
+    uint16_t groupId;
+    uint8_t sceneCount;
+    DataModel::List<uint8_t> sceneList;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetSceneMembershipResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetSceneMembershipResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint8_t capacity;
+    uint16_t groupId;
+    uint8_t sceneCount;
+    DataModel::DecodableList<uint8_t> sceneList;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetSceneMembershipResponse
 namespace EnhancedAddScene {
+enum class Fields
+{
+    kGroupId            = 0,
+    kSceneId            = 1,
+    kTransitionTime     = 2,
+    kSceneName          = 3,
+    kExtensionFieldSets = 4,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnhancedAddScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    Span<const char> sceneName;
+    DataModel::List<SceneExtensionFieldSet::Type> extensionFieldSets;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnhancedAddScene
+public:
+    static constexpr CommandId GetCommandId() { return EnhancedAddScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    Span<const char> sceneName;
+    DataModel::DecodableList<SceneExtensionFieldSet::DecodableType> extensionFieldSets;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnhancedAddScene
 namespace EnhancedAddSceneResponse {
+enum class Fields
+{
+    kStatus  = 0,
+    kGroupId = 1,
+    kSceneId = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnhancedAddSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnhancedAddSceneResponse
+public:
+    static constexpr CommandId GetCommandId() { return EnhancedAddSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnhancedAddSceneResponse
 namespace EnhancedViewScene {
+enum class Fields
+{
+    kGroupId = 0,
+    kSceneId = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnhancedViewScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint16_t groupId;
+    uint8_t sceneId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnhancedViewScene
+public:
+    static constexpr CommandId GetCommandId() { return EnhancedViewScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint16_t groupId;
+    uint8_t sceneId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnhancedViewScene
 namespace EnhancedViewSceneResponse {
+enum class Fields
+{
+    kStatus             = 0,
+    kGroupId            = 1,
+    kSceneId            = 2,
+    kTransitionTime     = 3,
+    kSceneName          = 4,
+    kExtensionFieldSets = 5,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnhancedViewSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    Span<const char> sceneName;
+    DataModel::List<SceneExtensionFieldSet::Type> extensionFieldSets;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnhancedViewSceneResponse
+public:
+    static constexpr CommandId GetCommandId() { return EnhancedViewSceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint16_t groupId;
+    uint8_t sceneId;
+    uint16_t transitionTime;
+    Span<const char> sceneName;
+    DataModel::DecodableList<SceneExtensionFieldSet::DecodableType> extensionFieldSets;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnhancedViewSceneResponse
 namespace CopyScene {
+enum class Fields
+{
+    kMode        = 0,
+    kGroupIdFrom = 1,
+    kSceneIdFrom = 2,
+    kGroupIdTo   = 3,
+    kSceneIdTo   = 4,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return CopyScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t mode;
+    uint16_t groupIdFrom;
+    uint8_t sceneIdFrom;
+    uint16_t groupIdTo;
+    uint8_t sceneIdTo;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CopyScene
+public:
+    static constexpr CommandId GetCommandId() { return CopyScene::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t mode;
+    uint16_t groupIdFrom;
+    uint8_t sceneIdFrom;
+    uint16_t groupIdTo;
+    uint8_t sceneIdTo;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CopyScene
 namespace CopySceneResponse {
+enum class Fields
+{
+    kStatus      = 0,
+    kGroupIdFrom = 1,
+    kSceneIdFrom = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return CopySceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
+
+    uint8_t status;
+    uint16_t groupIdFrom;
+    uint8_t sceneIdFrom;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CopySceneResponse
+public:
+    static constexpr CommandId GetCommandId() { return CopySceneResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Scenes::Id; }
 
+    uint8_t status;
+    uint16_t groupIdFrom;
+    uint8_t sceneIdFrom;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CopySceneResponse
 } // namespace Commands
 } // namespace Scenes
 namespace OnOff {
@@ -450,115 +1198,286 @@
 
 namespace Commands {
 namespace Off {
+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 Off::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Off
+public:
+    static constexpr CommandId GetCommandId() { return Off::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Off
 namespace SampleMfgSpecificOffWithTransition {
+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 SampleMfgSpecificOffWithTransition::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SampleMfgSpecificOffWithTransition
+public:
+    static constexpr CommandId GetCommandId() { return SampleMfgSpecificOffWithTransition::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SampleMfgSpecificOffWithTransition
 namespace On {
+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 On::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace On
+public:
+    static constexpr CommandId GetCommandId() { return On::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace On
 namespace SampleMfgSpecificOnWithTransition {
+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 SampleMfgSpecificOnWithTransition::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SampleMfgSpecificOnWithTransition
+public:
+    static constexpr CommandId GetCommandId() { return SampleMfgSpecificOnWithTransition::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SampleMfgSpecificOnWithTransition
 namespace SampleMfgSpecificOnWithTransition2 {
+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 SampleMfgSpecificOnWithTransition2::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SampleMfgSpecificOnWithTransition2
+public:
+    static constexpr CommandId GetCommandId() { return SampleMfgSpecificOnWithTransition2::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SampleMfgSpecificOnWithTransition2
 namespace Toggle {
+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 Toggle::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Toggle
+public:
+    static constexpr CommandId GetCommandId() { return Toggle::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Toggle
 namespace SampleMfgSpecificToggleWithTransition {
+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 SampleMfgSpecificToggleWithTransition::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SampleMfgSpecificToggleWithTransition
+public:
+    static constexpr CommandId GetCommandId() { return SampleMfgSpecificToggleWithTransition::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SampleMfgSpecificToggleWithTransition
 namespace SampleMfgSpecificToggleWithTransition2 {
+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 SampleMfgSpecificToggleWithTransition2::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SampleMfgSpecificToggleWithTransition2
+public:
+    static constexpr CommandId GetCommandId() { return SampleMfgSpecificToggleWithTransition2::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SampleMfgSpecificToggleWithTransition2
 namespace OffWithEffect {
+enum class Fields
+{
+    kEffectId      = 0,
+    kEffectVariant = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return OffWithEffect::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    OnOffEffectIdentifier effectId;
+    OnOffDelayedAllOffEffectVariant effectVariant;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace OffWithEffect
+public:
+    static constexpr CommandId GetCommandId() { return OffWithEffect::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    OnOffEffectIdentifier effectId;
+    OnOffDelayedAllOffEffectVariant effectVariant;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OffWithEffect
 namespace OnWithRecallGlobalScene {
+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 OnWithRecallGlobalScene::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace OnWithRecallGlobalScene
+public:
+    static constexpr CommandId GetCommandId() { return OnWithRecallGlobalScene::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OnWithRecallGlobalScene
 namespace OnWithTimedOff {
+enum class Fields
+{
+    kOnOffControl = 0,
+    kOnTime       = 1,
+    kOffWaitTime  = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return OnWithTimedOff::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
+
+    uint8_t onOffControl;
+    uint16_t onTime;
+    uint16_t offWaitTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace OnWithTimedOff
+public:
+    static constexpr CommandId GetCommandId() { return OnWithTimedOff::Id; }
+    static constexpr ClusterId GetClusterId() { return OnOff::Id; }
 
+    uint8_t onOffControl;
+    uint16_t onTime;
+    uint16_t offWaitTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OnWithTimedOff
 } // namespace Commands
 } // namespace OnOff
 namespace OnOffSwitchConfiguration {
@@ -580,150 +1499,446 @@
 
 namespace Commands {
 namespace MoveToLevel {
+enum class Fields
+{
+    kLevel          = 0,
+    kTransitionTime = 1,
+    kOptionMask     = 2,
+    kOptionOverride = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MoveToLevel::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+
+    uint8_t level;
+    uint16_t transitionTime;
+    uint8_t optionMask;
+    uint8_t optionOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveToLevel
+public:
+    static constexpr CommandId GetCommandId() { return MoveToLevel::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
 
+    uint8_t level;
+    uint16_t transitionTime;
+    uint8_t optionMask;
+    uint8_t optionOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToLevel
 namespace Move {
+enum class Fields
+{
+    kMoveMode       = 0,
+    kRate           = 1,
+    kOptionMask     = 2,
+    kOptionOverride = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Move::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+
+    MoveMode moveMode;
+    uint8_t rate;
+    uint8_t optionMask;
+    uint8_t optionOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Move
+public:
+    static constexpr CommandId GetCommandId() { return Move::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
 
+    MoveMode moveMode;
+    uint8_t rate;
+    uint8_t optionMask;
+    uint8_t optionOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Move
 namespace Step {
+enum class Fields
+{
+    kStepMode       = 0,
+    kStepSize       = 1,
+    kTransitionTime = 2,
+    kOptionMask     = 3,
+    kOptionOverride = 4,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Step::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+
+    StepMode stepMode;
+    uint8_t stepSize;
+    uint16_t transitionTime;
+    uint8_t optionMask;
+    uint8_t optionOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Step
+public:
+    static constexpr CommandId GetCommandId() { return Step::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
 
+    StepMode stepMode;
+    uint8_t stepSize;
+    uint16_t transitionTime;
+    uint8_t optionMask;
+    uint8_t optionOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Step
 namespace Stop {
+enum class Fields
+{
+    kOptionMask     = 0,
+    kOptionOverride = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Stop::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+
+    uint8_t optionMask;
+    uint8_t optionOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Stop
+public:
+    static constexpr CommandId GetCommandId() { return Stop::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
 
+    uint8_t optionMask;
+    uint8_t optionOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Stop
 namespace MoveToLevelWithOnOff {
+enum class Fields
+{
+    kLevel          = 0,
+    kTransitionTime = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MoveToLevelWithOnOff::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+
+    uint8_t level;
+    uint16_t transitionTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveToLevelWithOnOff
+public:
+    static constexpr CommandId GetCommandId() { return MoveToLevelWithOnOff::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
 
+    uint8_t level;
+    uint16_t transitionTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToLevelWithOnOff
 namespace MoveWithOnOff {
+enum class Fields
+{
+    kMoveMode = 0,
+    kRate     = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return MoveWithOnOff::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+
+    MoveMode moveMode;
+    uint8_t rate;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveWithOnOff
+public:
+    static constexpr CommandId GetCommandId() { return MoveWithOnOff::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
 
+    MoveMode moveMode;
+    uint8_t rate;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveWithOnOff
 namespace StepWithOnOff {
+enum class Fields
+{
+    kStepMode       = 0,
+    kStepSize       = 1,
+    kTransitionTime = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return StepWithOnOff::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+
+    StepMode stepMode;
+    uint8_t stepSize;
+    uint16_t transitionTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StepWithOnOff
+public:
+    static constexpr CommandId GetCommandId() { return StepWithOnOff::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
 
+    StepMode stepMode;
+    uint8_t stepSize;
+    uint16_t transitionTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StepWithOnOff
 namespace StopWithOnOff {
+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 StopWithOnOff::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StopWithOnOff
+public:
+    static constexpr CommandId GetCommandId() { return StopWithOnOff::Id; }
+    static constexpr ClusterId GetClusterId() { return LevelControl::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StopWithOnOff
 } // namespace Commands
 } // namespace LevelControl
 namespace Alarms {
 
 namespace Commands {
 namespace ResetAlarm {
+enum class Fields
+{
+    kAlarmCode = 0,
+    kClusterId = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ResetAlarm::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
+
+    uint8_t alarmCode;
+    chip::ClusterId clusterId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ResetAlarm
+public:
+    static constexpr CommandId GetCommandId() { return ResetAlarm::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
 
+    uint8_t alarmCode;
+    chip::ClusterId clusterId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetAlarm
 namespace Alarm {
+enum class Fields
+{
+    kAlarmCode = 0,
+    kClusterId = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Alarm::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
+
+    uint8_t alarmCode;
+    chip::ClusterId clusterId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Alarm
+public:
+    static constexpr CommandId GetCommandId() { return Alarm::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
 
+    uint8_t alarmCode;
+    chip::ClusterId clusterId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Alarm
 namespace ResetAllAlarms {
+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 ResetAllAlarms::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ResetAllAlarms
+public:
+    static constexpr CommandId GetCommandId() { return ResetAllAlarms::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetAllAlarms
 namespace GetAlarmResponse {
+enum class Fields
+{
+    kStatus    = 0,
+    kAlarmCode = 1,
+    kClusterId = 2,
+    kTimeStamp = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetAlarmResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
+
+    uint8_t status;
+    uint8_t alarmCode;
+    chip::ClusterId clusterId;
+    uint32_t timeStamp;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetAlarmResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetAlarmResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
 
+    uint8_t status;
+    uint8_t alarmCode;
+    chip::ClusterId clusterId;
+    uint32_t timeStamp;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetAlarmResponse
 namespace GetAlarm {
+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 GetAlarm::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetAlarm
+public:
+    static constexpr CommandId GetCommandId() { return GetAlarm::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetAlarm
 namespace ResetAlarmLog {
+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 ResetAlarmLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ResetAlarmLog
+public:
+    static constexpr CommandId GetCommandId() { return ResetAlarmLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Alarms::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetAlarmLog
 } // namespace Commands
 } // namespace Alarms
 namespace Time {
@@ -735,12 +1950,12 @@
 namespace PowerProfile {
 
 namespace PowerProfileRecord {
-enum FieldId
+enum class Fields
 {
-    kPowerProfileIdFieldId            = 0,
-    kEnergyPhaseIdFieldId             = 1,
-    kPowerProfileRemoteControlFieldId = 2,
-    kPowerProfileStateFieldId         = 3,
+    kPowerProfileId            = 0,
+    kEnergyPhaseId             = 1,
+    kPowerProfileRemoteControl = 2,
+    kPowerProfileState         = 3,
 };
 
 struct Type
@@ -759,10 +1974,10 @@
 
 } // namespace PowerProfileRecord
 namespace ScheduledPhase {
-enum FieldId
+enum class Fields
 {
-    kEnergyPhaseIdFieldId = 0,
-    kScheduledTimeFieldId = 1,
+    kEnergyPhaseId = 0,
+    kScheduledTime = 1,
 };
 
 struct Type
@@ -779,14 +1994,14 @@
 
 } // namespace ScheduledPhase
 namespace TransferredPhase {
-enum FieldId
+enum class Fields
 {
-    kEnergyPhaseIdFieldId      = 0,
-    kMacroPhaseIdFieldId       = 1,
-    kExpectedDurationFieldId   = 2,
-    kPeakPowerFieldId          = 3,
-    kEnergyFieldId             = 4,
-    kMaxActivationDelayFieldId = 5,
+    kEnergyPhaseId      = 0,
+    kMacroPhaseId       = 1,
+    kExpectedDuration   = 2,
+    kPeakPower          = 3,
+    kEnergy             = 4,
+    kMaxActivationDelay = 5,
 };
 
 struct Type
@@ -809,215 +2024,675 @@
 
 namespace Commands {
 namespace PowerProfileRequest {
+enum class Fields
+{
+    kPowerProfileId = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PowerProfileRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfileRequest
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfileRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfileRequest
 namespace PowerProfileNotification {
+enum class Fields
+{
+    kTotalProfileNum        = 0,
+    kPowerProfileId         = 1,
+    kNumOfTransferredPhases = 2,
+    kTransferredPhases      = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PowerProfileNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t totalProfileNum;
+    uint8_t powerProfileId;
+    uint8_t numOfTransferredPhases;
+    DataModel::List<TransferredPhase::Type> transferredPhases;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfileNotification
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfileNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t totalProfileNum;
+    uint8_t powerProfileId;
+    uint8_t numOfTransferredPhases;
+    DataModel::DecodableList<TransferredPhase::DecodableType> transferredPhases;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfileNotification
 namespace PowerProfileStateRequest {
+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 PowerProfileStateRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfileStateRequest
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfileStateRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfileStateRequest
 namespace PowerProfileResponse {
+enum class Fields
+{
+    kTotalProfileNum        = 0,
+    kPowerProfileId         = 1,
+    kNumOfTransferredPhases = 2,
+    kTransferredPhases      = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PowerProfileResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t totalProfileNum;
+    uint8_t powerProfileId;
+    uint8_t numOfTransferredPhases;
+    DataModel::List<TransferredPhase::Type> transferredPhases;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfileResponse
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfileResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t totalProfileNum;
+    uint8_t powerProfileId;
+    uint8_t numOfTransferredPhases;
+    DataModel::DecodableList<TransferredPhase::DecodableType> transferredPhases;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfileResponse
 namespace GetPowerProfilePriceResponse {
+enum class Fields
+{
+    kPowerProfileId     = 0,
+    kCurrency           = 1,
+    kPrice              = 2,
+    kPriceTrailingDigit = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetPowerProfilePriceResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+    uint16_t currency;
+    uint32_t price;
+    uint8_t priceTrailingDigit;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetPowerProfilePriceResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetPowerProfilePriceResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    uint16_t currency;
+    uint32_t price;
+    uint8_t priceTrailingDigit;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPowerProfilePriceResponse
 namespace PowerProfileStateResponse {
+enum class Fields
+{
+    kPowerProfileCount   = 0,
+    kPowerProfileRecords = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PowerProfileStateResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileCount;
+    DataModel::List<PowerProfileRecord::Type> powerProfileRecords;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfileStateResponse
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfileStateResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileCount;
+    DataModel::DecodableList<PowerProfileRecord::DecodableType> powerProfileRecords;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfileStateResponse
 namespace GetOverallSchedulePriceResponse {
+enum class Fields
+{
+    kCurrency           = 0,
+    kPrice              = 1,
+    kPriceTrailingDigit = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetOverallSchedulePriceResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint16_t currency;
+    uint32_t price;
+    uint8_t priceTrailingDigit;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetOverallSchedulePriceResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetOverallSchedulePriceResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint16_t currency;
+    uint32_t price;
+    uint8_t priceTrailingDigit;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetOverallSchedulePriceResponse
 namespace GetPowerProfilePrice {
+enum class Fields
+{
+    kPowerProfileId = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetPowerProfilePrice::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetPowerProfilePrice
+public:
+    static constexpr CommandId GetCommandId() { return GetPowerProfilePrice::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPowerProfilePrice
 namespace EnergyPhasesScheduleNotification {
+enum class Fields
+{
+    kPowerProfileId       = 0,
+    kNumOfScheduledPhases = 1,
+    kScheduledPhases      = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+    uint8_t numOfScheduledPhases;
+    DataModel::List<ScheduledPhase::Type> scheduledPhases;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnergyPhasesScheduleNotification
+public:
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    uint8_t numOfScheduledPhases;
+    DataModel::DecodableList<ScheduledPhase::DecodableType> scheduledPhases;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnergyPhasesScheduleNotification
 namespace PowerProfilesStateNotification {
+enum class Fields
+{
+    kPowerProfileCount   = 0,
+    kPowerProfileRecords = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PowerProfilesStateNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileCount;
+    DataModel::List<PowerProfileRecord::Type> powerProfileRecords;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfilesStateNotification
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfilesStateNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileCount;
+    DataModel::DecodableList<PowerProfileRecord::DecodableType> powerProfileRecords;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfilesStateNotification
 namespace EnergyPhasesScheduleResponse {
+enum class Fields
+{
+    kPowerProfileId       = 0,
+    kNumOfScheduledPhases = 1,
+    kScheduledPhases      = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+    uint8_t numOfScheduledPhases;
+    DataModel::List<ScheduledPhase::Type> scheduledPhases;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnergyPhasesScheduleResponse
+public:
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    uint8_t numOfScheduledPhases;
+    DataModel::DecodableList<ScheduledPhase::DecodableType> scheduledPhases;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnergyPhasesScheduleResponse
 namespace GetOverallSchedulePrice {
+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 GetOverallSchedulePrice::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetOverallSchedulePrice
+public:
+    static constexpr CommandId GetCommandId() { return GetOverallSchedulePrice::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetOverallSchedulePrice
 namespace PowerProfileScheduleConstraintsRequest {
+enum class Fields
+{
+    kPowerProfileId = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PowerProfileScheduleConstraintsRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfileScheduleConstraintsRequest
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfileScheduleConstraintsRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfileScheduleConstraintsRequest
 namespace EnergyPhasesScheduleRequest {
+enum class Fields
+{
+    kPowerProfileId = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnergyPhasesScheduleRequest
+public:
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnergyPhasesScheduleRequest
 namespace EnergyPhasesScheduleStateRequest {
+enum class Fields
+{
+    kPowerProfileId = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleStateRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnergyPhasesScheduleStateRequest
+public:
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleStateRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnergyPhasesScheduleStateRequest
 namespace EnergyPhasesScheduleStateResponse {
+enum class Fields
+{
+    kPowerProfileId       = 0,
+    kNumOfScheduledPhases = 1,
+    kScheduledPhases      = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleStateResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+    uint8_t numOfScheduledPhases;
+    DataModel::List<ScheduledPhase::Type> scheduledPhases;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnergyPhasesScheduleStateResponse
+public:
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleStateResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    uint8_t numOfScheduledPhases;
+    DataModel::DecodableList<ScheduledPhase::DecodableType> scheduledPhases;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnergyPhasesScheduleStateResponse
 namespace GetPowerProfilePriceExtendedResponse {
+enum class Fields
+{
+    kPowerProfileId     = 0,
+    kCurrency           = 1,
+    kPrice              = 2,
+    kPriceTrailingDigit = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetPowerProfilePriceExtendedResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+    uint16_t currency;
+    uint32_t price;
+    uint8_t priceTrailingDigit;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetPowerProfilePriceExtendedResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetPowerProfilePriceExtendedResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    uint16_t currency;
+    uint32_t price;
+    uint8_t priceTrailingDigit;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPowerProfilePriceExtendedResponse
 namespace EnergyPhasesScheduleStateNotification {
+enum class Fields
+{
+    kPowerProfileId       = 0,
+    kNumOfScheduledPhases = 1,
+    kScheduledPhases      = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleStateNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+    uint8_t numOfScheduledPhases;
+    DataModel::List<ScheduledPhase::Type> scheduledPhases;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnergyPhasesScheduleStateNotification
+public:
+    static constexpr CommandId GetCommandId() { return EnergyPhasesScheduleStateNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    uint8_t numOfScheduledPhases;
+    DataModel::DecodableList<ScheduledPhase::DecodableType> scheduledPhases;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnergyPhasesScheduleStateNotification
 namespace PowerProfileScheduleConstraintsNotification {
+enum class Fields
+{
+    kPowerProfileId = 0,
+    kStartAfter     = 1,
+    kStopBefore     = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PowerProfileScheduleConstraintsNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+    uint16_t startAfter;
+    uint16_t stopBefore;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfileScheduleConstraintsNotification
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfileScheduleConstraintsNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    uint16_t startAfter;
+    uint16_t stopBefore;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfileScheduleConstraintsNotification
 namespace PowerProfileScheduleConstraintsResponse {
+enum class Fields
+{
+    kPowerProfileId = 0,
+    kStartAfter     = 1,
+    kStopBefore     = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return PowerProfileScheduleConstraintsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t powerProfileId;
+    uint16_t startAfter;
+    uint16_t stopBefore;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PowerProfileScheduleConstraintsResponse
+public:
+    static constexpr CommandId GetCommandId() { return PowerProfileScheduleConstraintsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t powerProfileId;
+    uint16_t startAfter;
+    uint16_t stopBefore;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerProfileScheduleConstraintsResponse
 namespace GetPowerProfilePriceExtended {
+enum class Fields
+{
+    kOptions               = 0,
+    kPowerProfileId        = 1,
+    kPowerProfileStartTime = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetPowerProfilePriceExtended::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
+
+    uint8_t options;
+    uint8_t powerProfileId;
+    uint16_t powerProfileStartTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetPowerProfilePriceExtended
+public:
+    static constexpr CommandId GetCommandId() { return GetPowerProfilePriceExtended::Id; }
+    static constexpr ClusterId GetClusterId() { return PowerProfile::Id; }
 
+    uint8_t options;
+    uint8_t powerProfileId;
+    uint16_t powerProfileStartTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPowerProfilePriceExtended
 } // namespace Commands
 } // namespace PowerProfile
 namespace ApplianceControl {
@@ -1067,100 +2742,250 @@
 
 namespace Commands {
 namespace ExecutionOfACommand {
-struct Type
+enum class Fields
 {
-};
-
-struct DecodableType
-{
-};
-} // namespace ExecutionOfACommand
-
-namespace SignalStateResponse {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace SignalStateResponse
-
-namespace SignalState {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace SignalState
-
-namespace SignalStateNotification {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace SignalStateNotification
-
-namespace WriteFunctions {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace WriteFunctions
-
-namespace OverloadPauseResume {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace OverloadPauseResume
-
-namespace OverloadPause {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace OverloadPause
-
-namespace OverloadWarning {
-struct Type
-{
-};
-
-struct DecodableType
-{
-};
-} // namespace OverloadWarning
-
-} // namespace Commands
-} // namespace ApplianceControl
-namespace Descriptor {
-
-namespace DeviceType {
-enum FieldId
-{
-    kTypeFieldId     = 0,
-    kRevisionFieldId = 1,
+    kCommandId = 0,
 };
 
 struct Type
 {
 public:
-    uint32_t type;
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ExecutionOfACommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    CommandIdentification commandId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return ExecutionOfACommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    CommandIdentification commandId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ExecutionOfACommand
+namespace SignalStateResponse {
+enum class Fields
+{
+    kApplianceStatus                   = 0,
+    kRemoteEnableFlagsAndDeviceStatus2 = 1,
+    kApplianceStatus2                  = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SignalStateResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    ApplianceStatus applianceStatus;
+    uint8_t remoteEnableFlagsAndDeviceStatus2;
+    ApplianceStatus applianceStatus2;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SignalStateResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    ApplianceStatus applianceStatus;
+    uint8_t remoteEnableFlagsAndDeviceStatus2;
+    ApplianceStatus applianceStatus2;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SignalStateResponse
+namespace SignalState {
+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 SignalState::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SignalState::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SignalState
+namespace SignalStateNotification {
+enum class Fields
+{
+    kApplianceStatus                   = 0,
+    kRemoteEnableFlagsAndDeviceStatus2 = 1,
+    kApplianceStatus2                  = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SignalStateNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    ApplianceStatus applianceStatus;
+    uint8_t remoteEnableFlagsAndDeviceStatus2;
+    ApplianceStatus applianceStatus2;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return SignalStateNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    ApplianceStatus applianceStatus;
+    uint8_t remoteEnableFlagsAndDeviceStatus2;
+    ApplianceStatus applianceStatus2;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SignalStateNotification
+namespace WriteFunctions {
+enum class Fields
+{
+    kFunctionId       = 0,
+    kFunctionDataType = 1,
+    kFunctionData     = 2,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return WriteFunctions::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    uint16_t functionId;
+    uint8_t functionDataType;
+    DataModel::List<uint8_t> functionData;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return WriteFunctions::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    uint16_t functionId;
+    uint8_t functionDataType;
+    DataModel::DecodableList<uint8_t> functionData;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace WriteFunctions
+namespace OverloadPauseResume {
+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 OverloadPauseResume::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return OverloadPauseResume::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OverloadPauseResume
+namespace OverloadPause {
+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 OverloadPause::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return OverloadPause::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OverloadPause
+namespace OverloadWarning {
+enum class Fields
+{
+    kWarningEvent = 0,
+};
+
+struct Type
+{
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return OverloadWarning::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    WarningEvent warningEvent;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return OverloadWarning::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceControl::Id; }
+
+    WarningEvent warningEvent;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OverloadWarning
+} // namespace Commands
+} // namespace ApplianceControl
+namespace Descriptor {
+
+namespace DeviceType {
+enum class Fields
+{
+    kType     = 0,
+    kRevision = 1,
+};
+
+struct Type
+{
+public:
+    chip::DeviceTypeId type;
     uint16_t revision;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
@@ -1176,100 +3001,241 @@
 
 namespace Commands {
 namespace CheckIn {
+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 CheckIn::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CheckIn
+public:
+    static constexpr CommandId GetCommandId() { return CheckIn::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CheckIn
 namespace CheckInResponse {
+enum class Fields
+{
+    kStartFastPolling = 0,
+    kFastPollTimeout  = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return CheckInResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+
+    bool startFastPolling;
+    uint16_t fastPollTimeout;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CheckInResponse
+public:
+    static constexpr CommandId GetCommandId() { return CheckInResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
 
+    bool startFastPolling;
+    uint16_t fastPollTimeout;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CheckInResponse
 namespace FastPollStop {
+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 FastPollStop::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace FastPollStop
+public:
+    static constexpr CommandId GetCommandId() { return FastPollStop::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace FastPollStop
 namespace SetLongPollInterval {
+enum class Fields
+{
+    kNewLongPollInterval = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SetLongPollInterval::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+
+    uint32_t newLongPollInterval;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetLongPollInterval
+public:
+    static constexpr CommandId GetCommandId() { return SetLongPollInterval::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
 
+    uint32_t newLongPollInterval;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetLongPollInterval
 namespace SetShortPollInterval {
+enum class Fields
+{
+    kNewShortPollInterval = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SetShortPollInterval::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
+
+    uint16_t newShortPollInterval;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetShortPollInterval
+public:
+    static constexpr CommandId GetCommandId() { return SetShortPollInterval::Id; }
+    static constexpr ClusterId GetClusterId() { return PollControl::Id; }
 
+    uint16_t newShortPollInterval;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetShortPollInterval
 } // namespace Commands
 } // namespace PollControl
 namespace Basic {
 
 namespace Commands {
 namespace StartUp {
+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 StartUp::Id; }
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StartUp
+public:
+    static constexpr CommandId GetCommandId() { return StartUp::Id; }
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StartUp
 namespace MfgSpecificPing {
+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 MfgSpecificPing::Id; }
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MfgSpecificPing
+public:
+    static constexpr CommandId GetCommandId() { return MfgSpecificPing::Id; }
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MfgSpecificPing
 namespace ShutDown {
+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 ShutDown::Id; }
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ShutDown
+public:
+    static constexpr CommandId GetCommandId() { return ShutDown::Id; }
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ShutDown
 namespace Leave {
+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 Leave::Id; }
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Leave
+public:
+    static constexpr CommandId GetCommandId() { return Leave::Id; }
+    static constexpr ClusterId GetClusterId() { return Basic::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Leave
 } // namespace Commands
 } // namespace Basic
 namespace OtaSoftwareUpdateProvider {
@@ -1298,55 +3264,196 @@
 
 namespace Commands {
 namespace QueryImage {
+enum class Fields
+{
+    kVendorId            = 0,
+    kProductId           = 1,
+    kHardwareVersion     = 2,
+    kSoftwareVersion     = 3,
+    kProtocolsSupported  = 4,
+    kLocation            = 5,
+    kRequestorCanConsent = 6,
+    kMetadataForProvider = 7,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return QueryImage::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
+
+    uint16_t vendorId;
+    uint16_t productId;
+    uint16_t hardwareVersion;
+    uint32_t softwareVersion;
+    OTADownloadProtocol protocolsSupported;
+    Span<const char> location;
+    bool requestorCanConsent;
+    chip::ByteSpan metadataForProvider;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace QueryImage
+public:
+    static constexpr CommandId GetCommandId() { return QueryImage::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
 
+    uint16_t vendorId;
+    uint16_t productId;
+    uint16_t hardwareVersion;
+    uint32_t softwareVersion;
+    OTADownloadProtocol protocolsSupported;
+    Span<const char> location;
+    bool requestorCanConsent;
+    chip::ByteSpan metadataForProvider;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace QueryImage
 namespace ApplyUpdateRequest {
+enum class Fields
+{
+    kUpdateToken = 0,
+    kNewVersion  = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ApplyUpdateRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
+
+    chip::ByteSpan updateToken;
+    uint32_t newVersion;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ApplyUpdateRequest
+public:
+    static constexpr CommandId GetCommandId() { return ApplyUpdateRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
 
+    chip::ByteSpan updateToken;
+    uint32_t newVersion;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ApplyUpdateRequest
 namespace NotifyUpdateApplied {
+enum class Fields
+{
+    kUpdateToken     = 0,
+    kSoftwareVersion = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return NotifyUpdateApplied::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
+
+    chip::ByteSpan updateToken;
+    uint32_t softwareVersion;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace NotifyUpdateApplied
+public:
+    static constexpr CommandId GetCommandId() { return NotifyUpdateApplied::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
 
+    chip::ByteSpan updateToken;
+    uint32_t softwareVersion;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NotifyUpdateApplied
 namespace QueryImageResponse {
+enum class Fields
+{
+    kStatus                = 0,
+    kDelayedActionTime     = 1,
+    kImageURI              = 2,
+    kSoftwareVersion       = 3,
+    kSoftwareVersionString = 4,
+    kUpdateToken           = 5,
+    kUserConsentNeeded     = 6,
+    kMetadataForRequestor  = 7,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return QueryImageResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
+
+    OTAQueryStatus status;
+    uint32_t delayedActionTime;
+    Span<const char> imageURI;
+    uint32_t softwareVersion;
+    Span<const char> softwareVersionString;
+    chip::ByteSpan updateToken;
+    bool userConsentNeeded;
+    chip::ByteSpan metadataForRequestor;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace QueryImageResponse
+public:
+    static constexpr CommandId GetCommandId() { return QueryImageResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
 
+    OTAQueryStatus status;
+    uint32_t delayedActionTime;
+    Span<const char> imageURI;
+    uint32_t softwareVersion;
+    Span<const char> softwareVersionString;
+    chip::ByteSpan updateToken;
+    bool userConsentNeeded;
+    chip::ByteSpan metadataForRequestor;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace QueryImageResponse
 namespace ApplyUpdateRequestResponse {
+enum class Fields
+{
+    kAction            = 0,
+    kDelayedActionTime = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ApplyUpdateRequestResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
+
+    OTAApplyUpdateAction action;
+    uint32_t delayedActionTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ApplyUpdateRequestResponse
+public:
+    static constexpr CommandId GetCommandId() { return ApplyUpdateRequestResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateProvider::Id; }
 
+    OTAApplyUpdateAction action;
+    uint32_t delayedActionTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ApplyUpdateRequestResponse
 } // namespace Commands
 } // namespace OtaSoftwareUpdateProvider
 namespace OtaSoftwareUpdateRequestor {
@@ -1360,15 +3467,42 @@
 
 namespace Commands {
 namespace AnnounceOtaProvider {
+enum class Fields
+{
+    kProviderLocation   = 0,
+    kVendorId           = 1,
+    kAnnouncementReason = 2,
+    kMetadataForNode    = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AnnounceOtaProvider::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateRequestor::Id; }
+
+    chip::ByteSpan providerLocation;
+    uint16_t vendorId;
+    OTAAnnouncementReason announcementReason;
+    chip::ByteSpan metadataForNode;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AnnounceOtaProvider
+public:
+    static constexpr CommandId GetCommandId() { return AnnounceOtaProvider::Id; }
+    static constexpr ClusterId GetClusterId() { return OtaSoftwareUpdateRequestor::Id; }
 
+    chip::ByteSpan providerLocation;
+    uint16_t vendorId;
+    OTAAnnouncementReason announcementReason;
+    chip::ByteSpan metadataForNode;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AnnounceOtaProvider
 } // namespace Commands
 } // namespace OtaSoftwareUpdateRequestor
 namespace PowerSource {
@@ -1391,9 +3525,9 @@
 };
 
 namespace BasicCommissioningInfoType {
-enum FieldId
+enum class Fields
 {
-    kFailSafeExpiryLengthMsFieldId = 0,
+    kFailSafeExpiryLengthMs = 0,
 };
 
 struct Type
@@ -1411,65 +3545,193 @@
 
 namespace Commands {
 namespace ArmFailSafe {
+enum class Fields
+{
+    kExpiryLengthSeconds = 0,
+    kBreadcrumb          = 1,
+    kTimeoutMs           = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ArmFailSafe::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+
+    uint16_t expiryLengthSeconds;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ArmFailSafe
+public:
+    static constexpr CommandId GetCommandId() { return ArmFailSafe::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
 
+    uint16_t expiryLengthSeconds;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ArmFailSafe
 namespace ArmFailSafeResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ArmFailSafeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+
+    GeneralCommissioningError errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ArmFailSafeResponse
+public:
+    static constexpr CommandId GetCommandId() { return ArmFailSafeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
 
+    GeneralCommissioningError errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ArmFailSafeResponse
 namespace SetRegulatoryConfig {
+enum class Fields
+{
+    kLocation    = 0,
+    kCountryCode = 1,
+    kBreadcrumb  = 2,
+    kTimeoutMs   = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SetRegulatoryConfig::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+
+    RegulatoryLocationType location;
+    Span<const char> countryCode;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetRegulatoryConfig
+public:
+    static constexpr CommandId GetCommandId() { return SetRegulatoryConfig::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
 
+    RegulatoryLocationType location;
+    Span<const char> countryCode;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetRegulatoryConfig
 namespace SetRegulatoryConfigResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return SetRegulatoryConfigResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+
+    GeneralCommissioningError errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetRegulatoryConfigResponse
+public:
+    static constexpr CommandId GetCommandId() { return SetRegulatoryConfigResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
 
+    GeneralCommissioningError errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetRegulatoryConfigResponse
 namespace CommissioningComplete {
+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 CommissioningComplete::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CommissioningComplete
+public:
+    static constexpr CommandId GetCommandId() { return CommissioningComplete::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CommissioningComplete
 namespace CommissioningCompleteResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return CommissioningCompleteResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
+
+    GeneralCommissioningError errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CommissioningCompleteResponse
+public:
+    static constexpr CommandId GetCommandId() { return CommissioningCompleteResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return GeneralCommissioning::Id; }
 
+    GeneralCommissioningError errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CommissioningCompleteResponse
 } // namespace Commands
 } // namespace GeneralCommissioning
 namespace NetworkCommissioning {
@@ -1499,9 +3761,9 @@
 };
 
 namespace ThreadInterfaceScanResult {
-enum FieldId
+enum class Fields
 {
-    kDiscoveryResponseFieldId = 0,
+    kDiscoveryResponse = 0,
 };
 
 struct Type
@@ -1517,13 +3779,13 @@
 
 } // namespace ThreadInterfaceScanResult
 namespace WiFiInterfaceScanResult {
-enum FieldId
+enum class Fields
 {
-    kSecurityFieldId      = 0,
-    kSsidFieldId          = 1,
-    kBssidFieldId         = 2,
-    kChannelFieldId       = 3,
-    kFrequencyBandFieldId = 4,
+    kSecurity      = 0,
+    kSsid          = 1,
+    kBssid         = 2,
+    kChannel       = 3,
+    kFrequencyBand = 4,
 };
 
 struct Type
@@ -1545,175 +3807,565 @@
 
 namespace Commands {
 namespace ScanNetworks {
+enum class Fields
+{
+    kSsid       = 0,
+    kBreadcrumb = 1,
+    kTimeoutMs  = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ScanNetworks::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    chip::ByteSpan ssid;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ScanNetworks
+public:
+    static constexpr CommandId GetCommandId() { return ScanNetworks::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    chip::ByteSpan ssid;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ScanNetworks
 namespace ScanNetworksResponse {
+enum class Fields
+{
+    kErrorCode         = 0,
+    kDebugText         = 1,
+    kWifiScanResults   = 2,
+    kThreadScanResults = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return ScanNetworksResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint8_t errorCode;
+    Span<const char> debugText;
+    DataModel::List<WiFiInterfaceScanResult::Type> wifiScanResults;
+    DataModel::List<ThreadInterfaceScanResult::Type> threadScanResults;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ScanNetworksResponse
+public:
+    static constexpr CommandId GetCommandId() { return ScanNetworksResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint8_t errorCode;
+    Span<const char> debugText;
+    DataModel::DecodableList<WiFiInterfaceScanResult::DecodableType> wifiScanResults;
+    DataModel::DecodableList<ThreadInterfaceScanResult::DecodableType> threadScanResults;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ScanNetworksResponse
 namespace AddWiFiNetwork {
+enum class Fields
+{
+    kSsid        = 0,
+    kCredentials = 1,
+    kBreadcrumb  = 2,
+    kTimeoutMs   = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddWiFiNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    chip::ByteSpan ssid;
+    chip::ByteSpan credentials;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AddWiFiNetwork
+public:
+    static constexpr CommandId GetCommandId() { return AddWiFiNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    chip::ByteSpan ssid;
+    chip::ByteSpan credentials;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddWiFiNetwork
 namespace AddWiFiNetworkResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddWiFiNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint8_t errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AddWiFiNetworkResponse
+public:
+    static constexpr CommandId GetCommandId() { return AddWiFiNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint8_t errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddWiFiNetworkResponse
 namespace UpdateWiFiNetwork {
+enum class Fields
+{
+    kSsid        = 0,
+    kCredentials = 1,
+    kBreadcrumb  = 2,
+    kTimeoutMs   = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return UpdateWiFiNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    chip::ByteSpan ssid;
+    chip::ByteSpan credentials;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UpdateWiFiNetwork
+public:
+    static constexpr CommandId GetCommandId() { return UpdateWiFiNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    chip::ByteSpan ssid;
+    chip::ByteSpan credentials;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdateWiFiNetwork
 namespace UpdateWiFiNetworkResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return UpdateWiFiNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint8_t errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UpdateWiFiNetworkResponse
+public:
+    static constexpr CommandId GetCommandId() { return UpdateWiFiNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint8_t errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdateWiFiNetworkResponse
 namespace AddThreadNetwork {
+enum class Fields
+{
+    kOperationalDataset = 0,
+    kBreadcrumb         = 1,
+    kTimeoutMs          = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddThreadNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    chip::ByteSpan operationalDataset;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AddThreadNetwork
+public:
+    static constexpr CommandId GetCommandId() { return AddThreadNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    chip::ByteSpan operationalDataset;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddThreadNetwork
 namespace AddThreadNetworkResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return AddThreadNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint8_t errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AddThreadNetworkResponse
+public:
+    static constexpr CommandId GetCommandId() { return AddThreadNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint8_t errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddThreadNetworkResponse
 namespace UpdateThreadNetwork {
+enum class Fields
+{
+    kOperationalDataset = 0,
+    kBreadcrumb         = 1,
+    kTimeoutMs          = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return UpdateThreadNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    chip::ByteSpan operationalDataset;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UpdateThreadNetwork
+public:
+    static constexpr CommandId GetCommandId() { return UpdateThreadNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    chip::ByteSpan operationalDataset;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdateThreadNetwork
 namespace UpdateThreadNetworkResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return UpdateThreadNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint8_t errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UpdateThreadNetworkResponse
+public:
+    static constexpr CommandId GetCommandId() { return UpdateThreadNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint8_t errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdateThreadNetworkResponse
 namespace RemoveNetwork {
+enum class Fields
+{
+    kNetworkID  = 0,
+    kBreadcrumb = 1,
+    kTimeoutMs  = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RemoveNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    chip::ByteSpan networkID;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RemoveNetwork
+public:
+    static constexpr CommandId GetCommandId() { return RemoveNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    chip::ByteSpan networkID;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveNetwork
 namespace RemoveNetworkResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RemoveNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint8_t errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RemoveNetworkResponse
+public:
+    static constexpr CommandId GetCommandId() { return RemoveNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint8_t errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveNetworkResponse
 namespace EnableNetwork {
+enum class Fields
+{
+    kNetworkID  = 0,
+    kBreadcrumb = 1,
+    kTimeoutMs  = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnableNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    chip::ByteSpan networkID;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnableNetwork
+public:
+    static constexpr CommandId GetCommandId() { return EnableNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    chip::ByteSpan networkID;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnableNetwork
 namespace EnableNetworkResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return EnableNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint8_t errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnableNetworkResponse
+public:
+    static constexpr CommandId GetCommandId() { return EnableNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint8_t errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnableNetworkResponse
 namespace DisableNetwork {
+enum class Fields
+{
+    kNetworkID  = 0,
+    kBreadcrumb = 1,
+    kTimeoutMs  = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return DisableNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    chip::ByteSpan networkID;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace DisableNetwork
+public:
+    static constexpr CommandId GetCommandId() { return DisableNetwork::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    chip::ByteSpan networkID;
+    uint64_t breadcrumb;
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DisableNetwork
 namespace DisableNetworkResponse {
+enum class Fields
+{
+    kErrorCode = 0,
+    kDebugText = 1,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return DisableNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint8_t errorCode;
+    Span<const char> debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace DisableNetworkResponse
+public:
+    static constexpr CommandId GetCommandId() { return DisableNetworkResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint8_t errorCode;
+    Span<const char> debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DisableNetworkResponse
 namespace GetLastNetworkCommissioningResult {
+enum class Fields
+{
+    kTimeoutMs = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return GetLastNetworkCommissioningResult::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
+
+    uint32_t timeoutMs;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetLastNetworkCommissioningResult
+public:
+    static constexpr CommandId GetCommandId() { return GetLastNetworkCommissioningResult::Id; }
+    static constexpr ClusterId GetClusterId() { return NetworkCommissioning::Id; }
 
+    uint32_t timeoutMs;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetLastNetworkCommissioningResult
 } // namespace Commands
 } // namespace NetworkCommissioning
 namespace DiagnosticLogs {
@@ -1742,25 +4394,76 @@
 
 namespace Commands {
 namespace RetrieveLogsRequest {
+enum class Fields
+{
+    kIntent                 = 0,
+    kRequestedProtocol      = 1,
+    kTransferFileDesignator = 2,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RetrieveLogsRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return DiagnosticLogs::Id; }
+
+    LogsIntent intent;
+    LogsTransferProtocol requestedProtocol;
+    chip::ByteSpan transferFileDesignator;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RetrieveLogsRequest
+public:
+    static constexpr CommandId GetCommandId() { return RetrieveLogsRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return DiagnosticLogs::Id; }
 
+    LogsIntent intent;
+    LogsTransferProtocol requestedProtocol;
+    chip::ByteSpan transferFileDesignator;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RetrieveLogsRequest
 namespace RetrieveLogsResponse {
+enum class Fields
+{
+    kStatus        = 0,
+    kContent       = 1,
+    kTimeStamp     = 2,
+    kTimeSinceBoot = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return RetrieveLogsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DiagnosticLogs::Id; }
+
+    LogsStatus status;
+    chip::ByteSpan content;
+    uint32_t timeStamp;
+    uint32_t timeSinceBoot;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RetrieveLogsResponse
+public:
+    static constexpr CommandId GetCommandId() { return RetrieveLogsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DiagnosticLogs::Id; }
 
+    LogsStatus status;
+    chip::ByteSpan content;
+    uint32_t timeStamp;
+    uint32_t timeSinceBoot;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RetrieveLogsResponse
 } // namespace Commands
 } // namespace DiagnosticLogs
 namespace GeneralDiagnostics {
@@ -1820,14 +4523,14 @@
 };
 
 namespace NetworkInterfaceType {
-enum FieldId
+enum class Fields
 {
-    kNameFieldId                            = 0,
-    kFabricConnectedFieldId                 = 1,
-    kOffPremiseServicesReachableIPv4FieldId = 2,
-    kOffPremiseServicesReachableIPv6FieldId = 3,
-    kHardwareAddressFieldId                 = 4,
-    kTypeFieldId                            = 5,
+    kName                            = 0,
+    kFabricConnected                 = 1,
+    kOffPremiseServicesReachableIPv4 = 2,
+    kOffPremiseServicesReachableIPv6 = 3,
+    kHardwareAddress                 = 4,
+    kType                            = 5,
 };
 
 struct Type
@@ -1852,13 +4555,13 @@
 namespace SoftwareDiagnostics {
 
 namespace ThreadMetrics {
-enum FieldId
+enum class Fields
 {
-    kIdFieldId               = 0,
-    kNameFieldId             = 1,
-    kStackFreeCurrentFieldId = 2,
-    kStackFreeMinimumFieldId = 3,
-    kStackSizeFieldId        = 4,
+    kId               = 0,
+    kName             = 1,
+    kStackFreeCurrent = 2,
+    kStackFreeMinimum = 3,
+    kStackSize        = 4,
 };
 
 struct Type
@@ -1880,15 +4583,29 @@
 
 namespace Commands {
 namespace ResetWatermarks {
+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 ResetWatermarks::Id; }
+    static constexpr ClusterId GetClusterId() { return SoftwareDiagnostics::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ResetWatermarks
+public:
+    static constexpr CommandId GetCommandId() { return ResetWatermarks::Id; }
+    static constexpr ClusterId GetClusterId() { return SoftwareDiagnostics::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetWatermarks
 } // namespace Commands
 } // namespace SoftwareDiagnostics
 namespace ThreadNetworkDiagnostics {
@@ -1913,22 +4630,22 @@
 };
 
 namespace NeighborTable {
-enum FieldId
+enum class Fields
 {
-    kExtAddressFieldId       = 0,
-    kAgeFieldId              = 1,
-    kRloc16FieldId           = 2,
-    kLinkFrameCounterFieldId = 3,
-    kMleFrameCounterFieldId  = 4,
-    kLqiFieldId              = 5,
-    kAverageRssiFieldId      = 6,
-    kLastRssiFieldId         = 7,
-    kFrameErrorRateFieldId   = 8,
-    kMessageErrorRateFieldId = 9,
-    kRxOnWhenIdleFieldId     = 10,
-    kFullThreadDeviceFieldId = 11,
-    kFullNetworkDataFieldId  = 12,
-    kIsChildFieldId          = 13,
+    kExtAddress       = 0,
+    kAge              = 1,
+    kRloc16           = 2,
+    kLinkFrameCounter = 3,
+    kMleFrameCounter  = 4,
+    kLqi              = 5,
+    kAverageRssi      = 6,
+    kLastRssi         = 7,
+    kFrameErrorRate   = 8,
+    kMessageErrorRate = 9,
+    kRxOnWhenIdle     = 10,
+    kFullThreadDevice = 11,
+    kFullNetworkData  = 12,
+    kIsChild          = 13,
 };
 
 struct Type
@@ -1957,20 +4674,20 @@
 
 } // namespace NeighborTable
 namespace OperationalDatasetComponents {
-enum FieldId
+enum class Fields
 {
-    kActiveTimestampPresentFieldId  = 0,
-    kPendingTimestampPresentFieldId = 1,
-    kMasterKeyPresentFieldId        = 2,
-    kNetworkNamePresentFieldId      = 3,
-    kExtendedPanIdPresentFieldId    = 4,
-    kMeshLocalPrefixPresentFieldId  = 5,
-    kDelayPresentFieldId            = 6,
-    kPanIdPresentFieldId            = 7,
-    kChannelPresentFieldId          = 8,
-    kPskcPresentFieldId             = 9,
-    kSecurityPolicyPresentFieldId   = 10,
-    kChannelMaskPresentFieldId      = 11,
+    kActiveTimestampPresent  = 0,
+    kPendingTimestampPresent = 1,
+    kMasterKeyPresent        = 2,
+    kNetworkNamePresent      = 3,
+    kExtendedPanIdPresent    = 4,
+    kMeshLocalPrefixPresent  = 5,
+    kDelayPresent            = 6,
+    kPanIdPresent            = 7,
+    kChannelPresent          = 8,
+    kPskcPresent             = 9,
+    kSecurityPolicyPresent   = 10,
+    kChannelMaskPresent      = 11,
 };
 
 struct Type
@@ -1997,18 +4714,18 @@
 
 } // namespace OperationalDatasetComponents
 namespace RouteTable {
-enum FieldId
+enum class Fields
 {
-    kExtAddressFieldId      = 0,
-    kRloc16FieldId          = 1,
-    kRouterIdFieldId        = 2,
-    kNextHopFieldId         = 3,
-    kPathCostFieldId        = 4,
-    kLQIInFieldId           = 5,
-    kLQIOutFieldId          = 6,
-    kAgeFieldId             = 7,
-    kAllocatedFieldId       = 8,
-    kLinkEstablishedFieldId = 9,
+    kExtAddress      = 0,
+    kRloc16          = 1,
+    kRouterId        = 2,
+    kNextHop         = 3,
+    kPathCost        = 4,
+    kLQIIn           = 5,
+    kLQIOut          = 6,
+    kAge             = 7,
+    kAllocated       = 8,
+    kLinkEstablished = 9,
 };
 
 struct Type
@@ -2033,10 +4750,10 @@
 
 } // namespace RouteTable
 namespace SecurityPolicy {
-enum FieldId
+enum class Fields
 {
-    kRotationTimeFieldId = 0,
-    kFlagsFieldId        = 1,
+    kRotationTime = 0,
+    kFlags        = 1,
 };
 
 struct Type
@@ -2055,15 +4772,29 @@
 
 namespace Commands {
 namespace ResetCounts {
+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 ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ResetCounts
+public:
+    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return ThreadNetworkDiagnostics::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetCounts
 } // namespace Commands
 } // namespace ThreadNetworkDiagnostics
 namespace WiFiNetworkDiagnostics {
@@ -2090,15 +4821,29 @@
 
 namespace Commands {
 namespace ResetCounts {
+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 ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ResetCounts
+public:
+    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return WiFiNetworkDiagnostics::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetCounts
 } // namespace Commands
 } // namespace WiFiNetworkDiagnostics
 namespace EthernetNetworkDiagnostics {
@@ -2119,60 +4864,130 @@
 
 namespace Commands {
 namespace ResetCounts {
+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 ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ResetCounts
+public:
+    static constexpr CommandId GetCommandId() { return ResetCounts::Id; }
+    static constexpr ClusterId GetClusterId() { return EthernetNetworkDiagnostics::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetCounts
 } // namespace Commands
 } // namespace EthernetNetworkDiagnostics
 namespace BridgedDeviceBasic {
 
 namespace Commands {
 namespace StartUp {
+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 StartUp::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StartUp
+public:
+    static constexpr CommandId GetCommandId() { return StartUp::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StartUp
 namespace ShutDown {
+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 ShutDown::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ShutDown
+public:
+    static constexpr CommandId GetCommandId() { return ShutDown::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ShutDown
 namespace Leave {
+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 Leave::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Leave
+public:
+    static constexpr CommandId GetCommandId() { return Leave::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Leave
 namespace ReachableChanged {
+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 ReachableChanged::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ReachableChanged
+public:
+    static constexpr CommandId GetCommandId() { return ReachableChanged::Id; }
+    static constexpr ClusterId GetClusterId() { return BridgedDeviceBasic::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ReachableChanged
 } // namespace Commands
 } // namespace BridgedDeviceBasic
 namespace Switch {
@@ -2189,35 +5004,100 @@
 
 namespace Commands {
 namespace OpenCommissioningWindow {
+enum class Fields
+{
+    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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace OpenCommissioningWindow
+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);
+};
+}; // namespace OpenCommissioningWindow
 namespace OpenBasicCommissioningWindow {
+enum class Fields
+{
+    kCommissioningTimeout = 0,
+};
+
 struct Type
 {
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace OpenBasicCommissioningWindow
+public:
+    static constexpr CommandId GetCommandId() { return OpenBasicCommissioningWindow::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
 
+    uint16_t commissioningTimeout;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OpenBasicCommissioningWindow
 namespace RevokeCommissioning {
+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 RevokeCommissioning::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RevokeCommissioning
+public:
+    static constexpr CommandId GetCommandId() { return RevokeCommissioning::Id; }
+    static constexpr ClusterId GetClusterId() { return AdministratorCommissioning::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RevokeCommissioning
 } // namespace Commands
 } // namespace AdministratorCommissioning
 namespace OperationalCredentials {
@@ -2237,14 +5117,14 @@
 };
 
 namespace FabricDescriptor {
-enum FieldId
+enum class Fields
 {
-    kFabricIndexFieldId   = 0,
-    kRootPublicKeyFieldId = 1,
-    kVendorIdFieldId      = 2,
-    kFabricIdFieldId      = 3,
-    kNodeIdFieldId        = 4,
-    kLabelFieldId         = 5,
+    kFabricIndex   = 0,
+    kRootPublicKey = 1,
+    kVendorId      = 2,
+    kFabricId      = 3,
+    kNodeId        = 4,
+    kLabel         = 5,
 };
 
 struct Type
@@ -2253,8 +5133,8 @@
     uint8_t fabricIndex;
     chip::ByteSpan rootPublicKey;
     uint16_t vendorId;
-    uint64_t fabricId;
-    uint64_t nodeId;
+    chip::FabricId fabricId;
+    chip::NodeId nodeId;
     chip::ByteSpan label;
 
     CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
@@ -2265,10 +5145,10 @@
 
 } // namespace FabricDescriptor
 namespace NOCStruct {
-enum FieldId
+enum class Fields
 {
-    kFabricIndexFieldId = 0,
-    kNocFieldId         = 1,
+    kFabricIndex = 0,
+    kNoc         = 1,
 };
 
 struct Type
@@ -2287,144 +5167,405 @@
 
 namespace Commands {
 namespace AttestationRequest {
+enum class Fields
+{
+    kAttestationNonce = 0,
+};
+
 struct Type
 {
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AttestationRequest
+public:
+    static constexpr CommandId GetCommandId() { return AttestationRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    chip::ByteSpan attestationNonce;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AttestationRequest
 namespace AttestationResponse {
+enum class Fields
+{
+    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 AttestationResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+
+    chip::ByteSpan attestationElements;
+    chip::ByteSpan signature;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AttestationResponse
+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);
+};
+}; // namespace AttestationResponse
 namespace CertificateChainRequest {
+enum class Fields
+{
+    kCertificateType = 0,
+};
+
 struct Type
 {
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CertificateChainRequest
+public:
+    static constexpr CommandId GetCommandId() { return CertificateChainRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    uint8_t certificateType;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CertificateChainRequest
 namespace CertificateChainResponse {
+enum class Fields
+{
+    kCertificate = 0,
+};
+
 struct Type
 {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CertificateChainResponse
+public:
+    static constexpr CommandId GetCommandId() { return CertificateChainResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    chip::ByteSpan certificate;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CertificateChainResponse
 namespace OpCSRRequest {
+enum class Fields
+{
+    kCSRNonce = 0,
+};
+
 struct Type
 {
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace OpCSRRequest
+public:
+    static constexpr CommandId GetCommandId() { return OpCSRRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    chip::ByteSpan cSRNonce;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 OpCSRResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+
+    chip::ByteSpan nOCSRElements;
+    chip::ByteSpan attestationSignature;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace OpCSRResponse
+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);
+};
+}; // namespace OpCSRResponse
 namespace AddNOC {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AddNOC
+public:
+    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;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddNOC
 namespace UpdateNOC {
+enum class Fields
+{
+    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 UpdateNOC::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+
+    chip::ByteSpan nOCValue;
+    chip::ByteSpan iCACValue;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UpdateNOC
+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);
+};
+}; // namespace UpdateNOC
 namespace NOCResponse {
+enum class Fields
+{
+    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 NOCResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
+
+    uint8_t statusCode;
+    uint8_t fabricIndex;
+    chip::ByteSpan debugText;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace NOCResponse
+public:
+    static constexpr CommandId GetCommandId() { return NOCResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    uint8_t statusCode;
+    uint8_t fabricIndex;
+    chip::ByteSpan debugText;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NOCResponse
 namespace UpdateFabricLabel {
+enum class Fields
+{
+    kLabel = 0,
+};
+
 struct Type
 {
+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; }
+
+    Span<const char> label;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UpdateFabricLabel
+public:
+    static constexpr CommandId GetCommandId() { return UpdateFabricLabel::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    Span<const char> label;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdateFabricLabel
 namespace RemoveFabric {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RemoveFabric
+public:
+    static constexpr CommandId GetCommandId() { return RemoveFabric::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    uint8_t fabricIndex;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveFabric
 namespace AddTrustedRootCertificate {
+enum class Fields
+{
+    kRootCertificate = 0,
+};
+
 struct Type
 {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AddTrustedRootCertificate
+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,
+};
+
 struct Type
 {
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RemoveTrustedRootCertificate
+public:
+    static constexpr CommandId GetCommandId() { return RemoveTrustedRootCertificate::Id; }
+    static constexpr ClusterId GetClusterId() { return OperationalCredentials::Id; }
 
+    chip::ByteSpan trustedRootIdentifier;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveTrustedRootCertificate
 } // namespace Commands
 } // namespace OperationalCredentials
 namespace FixedLabel {
 
 namespace LabelStruct {
-enum FieldId
+enum class Fields
 {
-    kLabelFieldId = 0,
-    kValueFieldId = 1,
+    kLabel = 0,
+    kValue = 1,
 };
 
 struct Type
@@ -2505,545 +5646,1707 @@
 
 namespace Commands {
 namespace LockDoor {
+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; }
+
+    Span<const char> pin;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LockDoor
+public:
+    static constexpr CommandId GetCommandId() { return LockDoor::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    Span<const char> pin;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LockDoor
 namespace LockDoorResponse {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LockDoorResponse
+public:
+    static constexpr CommandId GetCommandId() { return LockDoorResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LockDoorResponse
 namespace UnlockDoor {
+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; }
+
+    Span<const char> pin;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UnlockDoor
+public:
+    static constexpr CommandId GetCommandId() { return UnlockDoor::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    Span<const char> pin;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnlockDoor
 namespace UnlockDoorResponse {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UnlockDoorResponse
+public:
+    static constexpr CommandId GetCommandId() { return UnlockDoorResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnlockDoorResponse
 namespace Toggle {
+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 Toggle::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    Span<const char> pin;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Toggle
+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);
+};
+}; // namespace Toggle
 namespace ToggleResponse {
+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 ToggleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ToggleResponse
+public:
+    static constexpr CommandId GetCommandId() { return ToggleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ToggleResponse
 namespace UnlockWithTimeout {
+enum class Fields
+{
+    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 UnlockWithTimeout::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t timeoutInSeconds;
+    Span<const char> pin;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UnlockWithTimeout
+public:
+    static constexpr CommandId GetCommandId() { return UnlockWithTimeout::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t timeoutInSeconds;
+    Span<const char> pin;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnlockWithTimeout
 namespace UnlockWithTimeoutResponse {
+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 UnlockWithTimeoutResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UnlockWithTimeoutResponse
+public:
+    static constexpr CommandId GetCommandId() { return UnlockWithTimeoutResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnlockWithTimeoutResponse
 namespace GetLogRecord {
+enum class Fields
+{
+    kLogIndex = 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; }
+
+    uint16_t logIndex;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetLogRecord
+public:
+    static constexpr CommandId GetCommandId() { return GetLogRecord::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t logIndex;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetLogRecord
 namespace GetLogRecordResponse {
+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;
+    Span<const char> pin;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetLogRecordResponse
+public:
+    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;
+    Span<const char> pin;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetLogRecordResponse
 namespace SetPin {
+enum class Fields
+{
+    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 SetPin::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    Span<const char> pin;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetPin
+public:
+    static constexpr CommandId GetCommandId() { return SetPin::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    Span<const char> pin;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetPin
 namespace SetPinResponse {
+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 SetPinResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    DoorLockSetPinOrIdStatus status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetPinResponse
+public:
+    static constexpr CommandId GetCommandId() { return SetPinResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    DoorLockSetPinOrIdStatus status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetPinResponse
 namespace GetPin {
+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 GetPin::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetPin
+public:
+    static constexpr CommandId GetCommandId() { return GetPin::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPin
 namespace GetPinResponse {
+enum class Fields
+{
+    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 GetPinResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    Span<const char> pin;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetPinResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetPinResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    Span<const char> pin;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPinResponse
 namespace ClearPin {
+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 ClearPin::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearPin
+public:
+    static constexpr CommandId GetCommandId() { return ClearPin::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearPin
 namespace ClearPinResponse {
+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 ClearPinResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearPinResponse
+public:
+    static constexpr CommandId GetCommandId() { return ClearPinResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearPinResponse
 namespace ClearAllPins {
+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 ClearAllPins::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearAllPins
+public:
+    static constexpr CommandId GetCommandId() { return ClearAllPins::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearAllPins
 namespace ClearAllPinsResponse {
+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 ClearAllPinsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearAllPinsResponse
+public:
+    static constexpr CommandId GetCommandId() { return ClearAllPinsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearAllPinsResponse
 namespace SetUserStatus {
+enum class Fields
+{
+    kUserId     = 0,
+    kUserStatus = 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; }
+
+    uint16_t userId;
+    uint8_t userStatus;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetUserStatus
+public:
+    static constexpr CommandId GetCommandId() { return SetUserStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    uint8_t userStatus;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetUserStatus
 namespace SetUserStatusResponse {
+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 SetUserStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetUserStatusResponse
+public:
+    static constexpr CommandId GetCommandId() { return SetUserStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetUserStatusResponse
 namespace GetUserStatus {
+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 GetUserStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetUserStatus
+public:
+    static constexpr CommandId GetCommandId() { return GetUserStatus::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetUserStatus
 namespace GetUserStatusResponse {
+enum class Fields
+{
+    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 GetUserStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetUserStatusResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetUserStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetUserStatusResponse
 namespace SetWeekdaySchedule {
+enum class Fields
+{
+    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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetWeekdaySchedule
+public:
+    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 SetWeekdaySchedule
 namespace SetWeekdayScheduleResponse {
+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 SetWeekdayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetWeekdayScheduleResponse
+public:
+    static constexpr CommandId GetCommandId() { return SetWeekdayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 GetWeekdaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetWeekdaySchedule
+public:
+    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 GetWeekdaySchedule
 namespace GetWeekdayScheduleResponse {
+enum class Fields
+{
+    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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetWeekdayScheduleResponse
+public:
+    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 GetWeekdayScheduleResponse
 namespace ClearWeekdaySchedule {
+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 ClearWeekdaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearWeekdaySchedule
+public:
+    static constexpr CommandId GetCommandId() { return ClearWeekdaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearWeekdaySchedule
 namespace ClearWeekdayScheduleResponse {
+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 ClearWeekdayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearWeekdayScheduleResponse
+public:
+    static constexpr CommandId GetCommandId() { return ClearWeekdayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearWeekdayScheduleResponse
 namespace SetYeardaySchedule {
+enum class Fields
+{
+    kScheduleId     = 0,
+    kUserId         = 1,
+    kLocalStartTime = 2,
+    kLocalEndTime   = 3,
+};
+
 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 ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetYeardaySchedule
+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 SetYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetYeardayScheduleResponse
+public:
+    static constexpr CommandId GetCommandId() { return SetYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 GetYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetYeardaySchedule
+public:
+    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 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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetYeardayScheduleResponse
+public:
+    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 GetYeardayScheduleResponse
 namespace ClearYeardaySchedule {
+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 ClearYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearYeardaySchedule
+public:
+    static constexpr CommandId GetCommandId() { return ClearYeardaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearYeardaySchedule
 namespace ClearYeardayScheduleResponse {
+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 ClearYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearYeardayScheduleResponse
+public:
+    static constexpr CommandId GetCommandId() { return ClearYeardayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearYeardayScheduleResponse
 namespace SetHolidaySchedule {
+enum class Fields
+{
+    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 SetHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+    uint8_t operatingModeDuringHoliday;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetHolidaySchedule
+public:
+    static constexpr CommandId GetCommandId() { return SetHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    uint32_t localStartTime;
+    uint32_t localEndTime;
+    uint8_t operatingModeDuringHoliday;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetHolidaySchedule
 namespace SetHolidayScheduleResponse {
+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 SetHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetHolidayScheduleResponse
+public:
+    static constexpr CommandId GetCommandId() { return SetHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetHolidayScheduleResponse
 namespace GetHolidaySchedule {
+enum class Fields
+{
+    kScheduleId = 0,
+};
+
 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 ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetHolidaySchedule
+public:
+    static constexpr CommandId GetCommandId() { return GetHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetHolidayScheduleResponse
+public:
+    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 GetHolidayScheduleResponse
 namespace ClearHolidaySchedule {
+enum class Fields
+{
+    kScheduleId = 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 ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t scheduleId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearHolidaySchedule
+public:
+    static constexpr CommandId GetCommandId() { return ClearHolidaySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t scheduleId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearHolidaySchedule
 namespace ClearHolidayScheduleResponse {
+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 ClearHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearHolidayScheduleResponse
+public:
+    static constexpr CommandId GetCommandId() { return ClearHolidayScheduleResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearHolidayScheduleResponse
 namespace SetUserType {
+enum class Fields
+{
+    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 SetUserType::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+    DoorLockUserType userType;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetUserType
+public:
+    static constexpr CommandId GetCommandId() { return SetUserType::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    DoorLockUserType userType;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetUserType
 namespace SetUserTypeResponse {
+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 SetUserTypeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetUserTypeResponse
+public:
+    static constexpr CommandId GetCommandId() { return SetUserTypeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetUserTypeResponse
 namespace GetUserType {
+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 ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetUserType
+public:
+    static constexpr CommandId GetCommandId() { return GetUserType::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetUserType
 namespace GetUserTypeResponse {
+enum class Fields
+{
+    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 GetUserTypeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+    DoorLockUserType userType;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetUserTypeResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetUserTypeResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    DoorLockUserType userType;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 SetRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    Span<const char> id;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetRfid
+public:
+    static constexpr CommandId GetCommandId() { return SetRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    Span<const char> id;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 SetRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    DoorLockSetPinOrIdStatus status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetRfidResponse
+public:
+    static constexpr CommandId GetCommandId() { return SetRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    DoorLockSetPinOrIdStatus status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetRfidResponse
 namespace GetRfid {
+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 GetRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetRfid
+public:
+    static constexpr CommandId GetCommandId() { return GetRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetRfid
 namespace GetRfidResponse {
+enum class Fields
+{
+    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 GetRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    Span<const char> rfid;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetRfidResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    DoorLockUserStatus userStatus;
+    DoorLockUserType userType;
+    Span<const char> rfid;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetRfidResponse
 namespace ClearRfid {
+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 ClearRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint16_t userId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearRfid
+public:
+    static constexpr CommandId GetCommandId() { return ClearRfid::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint16_t userId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearRfid
 namespace ClearRfidResponse {
+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 ClearRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearRfidResponse
+public:
+    static constexpr CommandId GetCommandId() { return ClearRfidResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearRfidResponse
 namespace ClearAllRfids {
+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 ClearAllRfids::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearAllRfids
+public:
+    static constexpr CommandId GetCommandId() { return ClearAllRfids::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearAllRfids
 namespace ClearAllRfidsResponse {
+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 ClearAllRfidsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t status;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearAllRfidsResponse
+public:
+    static constexpr CommandId GetCommandId() { return ClearAllRfidsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t status;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearAllRfidsResponse
 namespace OperationEventNotification {
+enum class Fields
+{
+    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 OperationEventNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t source;
+    DoorLockOperationEventCode eventCode;
+    uint16_t userId;
+    Span<const char> pin;
+    uint32_t timeStamp;
+    Span<const char> data;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace OperationEventNotification
+public:
+    static constexpr CommandId GetCommandId() { return OperationEventNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t source;
+    DoorLockOperationEventCode eventCode;
+    uint16_t userId;
+    Span<const char> pin;
+    uint32_t timeStamp;
+    Span<const char> data;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OperationEventNotification
 namespace ProgrammingEventNotification {
+enum class Fields
+{
+    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 ProgrammingEventNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
+
+    uint8_t source;
+    DoorLockProgrammingEventCode eventCode;
+    uint16_t userId;
+    Span<const char> pin;
+    DoorLockUserType userType;
+    DoorLockUserStatus userStatus;
+    uint32_t timeStamp;
+    Span<const char> data;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ProgrammingEventNotification
+public:
+    static constexpr CommandId GetCommandId() { return ProgrammingEventNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return DoorLock::Id; }
 
+    uint8_t source;
+    DoorLockProgrammingEventCode eventCode;
+    uint16_t userId;
+    Span<const char> pin;
+    DoorLockUserType userType;
+    DoorLockUserStatus userStatus;
+    uint32_t timeStamp;
+    Span<const char> data;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ProgrammingEventNotification
 } // namespace Commands
 } // namespace DoorLock
 namespace WindowCovering {
@@ -3094,100 +7397,252 @@
 
 namespace Commands {
 namespace UpOrOpen {
+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 UpOrOpen::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace UpOrOpen
+public:
+    static constexpr CommandId GetCommandId() { return UpOrOpen::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpOrOpen
 namespace DownOrClose {
+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 DownOrClose::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace DownOrClose
+public:
+    static constexpr CommandId GetCommandId() { return DownOrClose::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DownOrClose
 namespace StopMotion {
+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 StopMotion::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StopMotion
+public:
+    static constexpr CommandId GetCommandId() { return StopMotion::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StopMotion
 namespace GoToLiftValue {
+enum class Fields
+{
+    kLiftValue = 0,
+};
+
 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; }
+
+    uint16_t liftValue;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GoToLiftValue
+public:
+    static constexpr CommandId GetCommandId() { return GoToLiftValue::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
+    uint16_t liftValue;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToLiftValue
 namespace GoToLiftPercentage {
+enum class Fields
+{
+    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 GoToLiftPercentage::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
+
+    uint8_t liftPercentageValue;
+    uint16_t liftPercent100thsValue;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GoToLiftPercentage
+public:
+    static constexpr CommandId GetCommandId() { return GoToLiftPercentage::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
+    uint8_t liftPercentageValue;
+    uint16_t liftPercent100thsValue;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToLiftPercentage
 namespace GoToTiltValue {
+enum class Fields
+{
+    kTiltValue = 0,
+};
+
 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; }
+
+    uint16_t tiltValue;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GoToTiltValue
+public:
+    static constexpr CommandId GetCommandId() { return GoToTiltValue::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
+    uint16_t tiltValue;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToTiltValue
 namespace GoToTiltPercentage {
+enum class Fields
+{
+    kTiltPercentageValue    = 0,
+    kTiltPercent100thsValue = 1,
+};
+
 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; }
+
+    uint8_t tiltPercentageValue;
+    uint16_t tiltPercent100thsValue;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GoToTiltPercentage
+public:
+    static constexpr CommandId GetCommandId() { return GoToTiltPercentage::Id; }
+    static constexpr ClusterId GetClusterId() { return WindowCovering::Id; }
 
+    uint8_t tiltPercentageValue;
+    uint16_t tiltPercent100thsValue;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToTiltPercentage
 } // namespace Commands
 } // namespace WindowCovering
 namespace BarrierControl {
 
 namespace Commands {
 namespace BarrierControlGoToPercent {
+enum class Fields
+{
+    kPercentOpen = 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; }
+
+    uint8_t percentOpen;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace BarrierControlGoToPercent
+public:
+    static constexpr CommandId GetCommandId() { return BarrierControlGoToPercent::Id; }
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
 
+    uint8_t percentOpen;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace BarrierControlGoToPercent
 namespace BarrierControlStop {
+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 BarrierControlStop::Id; }
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace BarrierControlStop
+public:
+    static constexpr CommandId GetCommandId() { return BarrierControlStop::Id; }
+    static constexpr ClusterId GetClusterId() { return BarrierControl::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace BarrierControlStop
 } // namespace Commands
 } // namespace BarrierControl
 namespace PumpConfigurationAndControl {
@@ -3222,75 +7677,232 @@
 
 namespace Commands {
 namespace SetpointRaiseLower {
+enum class Fields
+{
+    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 SetpointRaiseLower::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+
+    SetpointAdjustMode mode;
+    int8_t amount;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetpointRaiseLower
+public:
+    static constexpr CommandId GetCommandId() { return SetpointRaiseLower::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
+    SetpointAdjustMode mode;
+    int8_t amount;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetpointRaiseLower
 namespace CurrentWeeklySchedule {
+enum class Fields
+{
+    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 CurrentWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+
+    uint8_t numberOfTransitionsForSequence;
+    uint8_t dayOfWeekForSequence;
+    uint8_t modeForSequence;
+    DataModel::List<uint8_t> payload;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CurrentWeeklySchedule
+public:
+    static constexpr CommandId GetCommandId() { return CurrentWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
+    uint8_t numberOfTransitionsForSequence;
+    uint8_t dayOfWeekForSequence;
+    uint8_t modeForSequence;
+    DataModel::DecodableList<uint8_t> payload;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CurrentWeeklySchedule
 namespace SetWeeklySchedule {
+enum class Fields
+{
+    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 SetWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+
+    uint8_t numberOfTransitionsForSequence;
+    uint8_t dayOfWeekForSequence;
+    uint8_t modeForSequence;
+    DataModel::List<uint8_t> payload;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetWeeklySchedule
+public:
+    static constexpr CommandId GetCommandId() { return SetWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
+    uint8_t numberOfTransitionsForSequence;
+    uint8_t dayOfWeekForSequence;
+    uint8_t modeForSequence;
+    DataModel::DecodableList<uint8_t> payload;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetWeeklySchedule
 namespace RelayStatusLog {
+enum class Fields
+{
+    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 RelayStatusLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+
+    uint16_t timeOfDay;
+    uint16_t relayStatus;
+    int16_t localTemperature;
+    uint8_t humidityInPercentage;
+    int16_t setpoint;
+    uint16_t unreadEntries;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RelayStatusLog
+public:
+    static constexpr CommandId GetCommandId() { return RelayStatusLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
+    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 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 GetWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+
+    uint8_t daysToReturn;
+    uint8_t modeToReturn;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetWeeklySchedule
+public:
+    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 GetWeeklySchedule
 namespace ClearWeeklySchedule {
+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 ClearWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ClearWeeklySchedule
+public:
+    static constexpr CommandId GetCommandId() { return ClearWeeklySchedule::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearWeeklySchedule
 namespace GetRelayStatusLog {
+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 GetRelayStatusLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetRelayStatusLog
+public:
+    static constexpr CommandId GetCommandId() { return GetRelayStatusLog::Id; }
+    static constexpr ClusterId GetClusterId() { return Thermostat::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetRelayStatusLog
 } // namespace Commands
 } // namespace Thermostat
 namespace FanControl {
@@ -3360,195 +7972,753 @@
 
 namespace Commands {
 namespace MoveToHue {
+enum class Fields
+{
+    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 MoveToHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    uint8_t hue;
+    HueDirection direction;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveToHue
+public:
+    static constexpr CommandId GetCommandId() { return MoveToHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    uint8_t hue;
+    HueDirection direction;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToHue
 namespace MoveHue {
+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 MoveHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    HueMoveMode moveMode;
+    uint8_t rate;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveHue
+public:
+    static constexpr CommandId GetCommandId() { return MoveHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    HueMoveMode moveMode;
+    uint8_t rate;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveHue
 namespace StepHue {
+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 StepHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    HueStepMode stepMode;
+    uint8_t stepSize;
+    uint8_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StepHue
+public:
+    static constexpr CommandId GetCommandId() { return StepHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    HueStepMode stepMode;
+    uint8_t stepSize;
+    uint8_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StepHue
 namespace MoveToSaturation {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveToSaturation
+public:
+    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;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToSaturation
 namespace MoveSaturation {
+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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveSaturation
+public:
+    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 Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveSaturation
 namespace StepSaturation {
+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 StepSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    SaturationStepMode stepMode;
+    uint8_t stepSize;
+    uint8_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StepSaturation
+public:
+    static constexpr CommandId GetCommandId() { return StepSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    SaturationStepMode stepMode;
+    uint8_t stepSize;
+    uint8_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StepSaturation
 namespace MoveToHueAndSaturation {
+enum class Fields
+{
+    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 MoveToHueAndSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    uint8_t hue;
+    uint8_t saturation;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveToHueAndSaturation
+public:
+    static constexpr CommandId GetCommandId() { return MoveToHueAndSaturation::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    uint8_t hue;
+    uint8_t saturation;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToHueAndSaturation
 namespace MoveToColor {
+enum class Fields
+{
+    kColorX          = 0,
+    kColorY          = 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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveToColor
+public:
+    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 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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveColor
+public:
+    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 MoveColor
 namespace StepColor {
+enum class Fields
+{
+    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 StepColor::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    int16_t stepX;
+    int16_t stepY;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StepColor
+public:
+    static constexpr CommandId GetCommandId() { return StepColor::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    int16_t stepX;
+    int16_t stepY;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveToColorTemperature
+public:
+    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 MoveToColorTemperature
 namespace EnhancedMoveToHue {
+enum class Fields
+{
+    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 EnhancedMoveToHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    uint16_t enhancedHue;
+    HueDirection direction;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnhancedMoveToHue
+public:
+    static constexpr CommandId GetCommandId() { return EnhancedMoveToHue::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    uint16_t enhancedHue;
+    HueDirection direction;
+    uint16_t transitionTime;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnhancedMoveHue
+public:
+    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 EnhancedMoveHue
 namespace EnhancedStepHue {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnhancedStepHue
+public:
+    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;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EnhancedMoveToHueAndSaturation
+public:
+    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 EnhancedMoveToHueAndSaturation
 namespace ColorLoopSet {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ColorLoopSet
+public:
+    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;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 StopMoveStep::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StopMoveStep
+public:
+    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 StopMoveStep
 namespace MoveColorTemperature {
+enum class Fields
+{
+    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 MoveColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    HueMoveMode moveMode;
+    uint16_t rate;
+    uint16_t colorTemperatureMinimum;
+    uint16_t colorTemperatureMaximum;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MoveColorTemperature
+public:
+    static constexpr CommandId GetCommandId() { return MoveColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    HueMoveMode moveMode;
+    uint16_t rate;
+    uint16_t colorTemperatureMinimum;
+    uint16_t colorTemperatureMaximum;
+    uint8_t optionsMask;
+    uint8_t optionsOverride;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 StepColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
+
+    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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StepColorTemperature
+public:
+    static constexpr CommandId GetCommandId() { return StepColorTemperature::Id; }
+    static constexpr ClusterId GetClusterId() { return ColorControl::Id; }
 
+    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 StepColorTemperature
 } // namespace Commands
 } // namespace ColorControl
 namespace BallastConfiguration {
@@ -3697,75 +8867,207 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ZoneEnrollResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ZoneStatusChangeNotification
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace InitiateNormalOperationMode
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ZoneEnrollRequest
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace InitiateTestMode
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace InitiateNormalOperationModeResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace InitiateTestModeResponse
+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 IasZone
 namespace IasAce {
@@ -3852,10 +9154,10 @@
 };
 
 namespace IasAceZoneStatusResult {
-enum FieldId
+enum class Fields
 {
-    kZoneIdFieldId     = 0,
-    kZoneStatusFieldId = 1,
+    kZoneId     = 0,
+    kZoneStatus = 1,
 };
 
 struct Type
@@ -3874,220 +9176,697 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Arm
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ArmResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Bypass
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetZoneIdMapResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Emergency
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetZoneInformationResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Fire
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ZoneStatusChanged
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Panic
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace PanelStatusChanged
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetZoneIdMap
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetPanelStatusResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetZoneInformation
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SetBypassedZoneList
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetPanelStatus
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace BypassResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetBypassedZoneList
+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<IasAceZoneStatusResult::Type> zoneStatusResult;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetZoneStatusResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetZoneStatusResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return IasAce::Id; }
 
+    bool zoneStatusComplete;
+    uint8_t numberOfZones;
+    DataModel::DecodableList<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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetZoneStatus
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StartWarning
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Squawk
+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 IasWd
 namespace WakeOnLan {
@@ -4107,13 +9886,13 @@
 };
 
 namespace TvChannelInfo {
-enum FieldId
+enum class Fields
 {
-    kMajorNumberFieldId       = 0,
-    kMinorNumberFieldId       = 1,
-    kNameFieldId              = 2,
-    kCallSignFieldId          = 3,
-    kAffiliateCallSignFieldId = 4,
+    kMajorNumber       = 0,
+    kMinorNumber       = 1,
+    kName              = 2,
+    kCallSign          = 3,
+    kAffiliateCallSign = 4,
 };
 
 struct Type
@@ -4133,12 +9912,12 @@
 
 } // namespace TvChannelInfo
 namespace TvChannelLineupInfo {
-enum FieldId
+enum class Fields
 {
-    kOperatorNameFieldId   = 0,
-    kLineupNameFieldId     = 1,
-    kPostalCodeFieldId     = 2,
-    kLineupInfoTypeFieldId = 3,
+    kOperatorName   = 0,
+    kLineupName     = 1,
+    kPostalCode     = 2,
+    kLineupInfoType = 3,
 };
 
 struct Type
@@ -4159,45 +9938,123 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ChangeChannel
+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<TvChannelInfo::Type> channelMatch;
+    TvChannelErrorType errorType;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ChangeChannelResponse
+public:
+    static constexpr CommandId GetCommandId() { return ChangeChannelResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TvChannel::Id; }
 
+    DataModel::DecodableList<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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ChangeChannelByNumber
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SkipChannel
+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 TvChannel
 namespace TargetNavigator {
@@ -4210,10 +10067,10 @@
 };
 
 namespace NavigateTargetTargetInfo {
-enum FieldId
+enum class Fields
 {
-    kIdentifierFieldId = 0,
-    kNameFieldId       = 1,
+    kIdentifier = 0,
+    kName       = 1,
 };
 
 struct Type
@@ -4232,25 +10089,67 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace NavigateTarget
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace NavigateTargetResponse
+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 TargetNavigator
 namespace MediaPlayback {
@@ -4274,10 +10173,10 @@
 };
 
 namespace MediaPlaybackPosition {
-enum FieldId
+enum class Fields
 {
-    kUpdatedAtFieldId = 0,
-    kPositionFieldId  = 1,
+    kUpdatedAt = 0,
+    kPosition  = 1,
 };
 
 struct Type
@@ -4296,225 +10195,589 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaPlay
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaPlayResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaPause
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaPauseResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaStop
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaStopResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaStartOver
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaStartOverResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaPrevious
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaPreviousResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaNext
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaNextResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaRewind
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaRewindResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaFastForward
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaFastForwardResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaSkipForward
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaSkipForwardResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaSkipBackward
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaSkipBackwardResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaSeek
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MediaSeekResponse
+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 MediaPlayback
 namespace MediaInput {
@@ -4536,12 +10799,12 @@
 };
 
 namespace MediaInputInfo {
-enum FieldId
+enum class Fields
 {
-    kIndexFieldId       = 0,
-    kInputTypeFieldId   = 1,
-    kNameFieldId        = 2,
-    kDescriptionFieldId = 3,
+    kIndex       = 0,
+    kInputType   = 1,
+    kName        = 2,
+    kDescription = 3,
 };
 
 struct Type
@@ -4562,60 +10825,141 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SelectInput
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ShowInputStatus
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace HideInputStatus
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RenameInput
+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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Sleep
+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 {
@@ -4719,25 +11063,61 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SendKey
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SendKeyResponse
+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 {
@@ -4777,10 +11157,10 @@
 };
 
 namespace ContentLaunchAdditionalInfo {
-enum FieldId
+enum class Fields
 {
-    kNameFieldId  = 0,
-    kValueFieldId = 1,
+    kName  = 0,
+    kValue = 1,
 };
 
 struct Type
@@ -4797,11 +11177,11 @@
 
 } // namespace ContentLaunchAdditionalInfo
 namespace ContentLaunchParamater {
-enum FieldId
+enum class Fields
 {
-    kTypeFieldId           = 0,
-    kValueFieldId          = 1,
-    kExternalIDListFieldId = 2,
+    kType           = 0,
+    kValue          = 1,
+    kExternalIDList = 2,
 };
 
 struct Type
@@ -4825,14 +11205,14 @@
 
 } // namespace ContentLaunchParamater
 namespace ContentLaunchBrandingInformation {
-enum FieldId
+enum class Fields
 {
-    kProviderNameFieldId = 0,
-    kBackgroundFieldId   = 1,
-    kLogoFieldId         = 2,
-    kProgressBarFieldId  = 3,
-    kSplashFieldId       = 4,
-    kWaterMarkFieldId    = 5,
+    kProviderName = 0,
+    kBackground   = 1,
+    kLogo         = 2,
+    kProgressBar  = 3,
+    kSplash       = 4,
+    kWaterMark    = 5,
 };
 
 struct Type
@@ -4853,11 +11233,11 @@
 
 } // namespace ContentLaunchBrandingInformation
 namespace ContentLaunchDimension {
-enum FieldId
+enum class Fields
 {
-    kWidthFieldId  = 0,
-    kHeightFieldId = 1,
-    kMetricFieldId = 2,
+    kWidth  = 0,
+    kHeight = 1,
+    kMetric = 2,
 };
 
 struct Type
@@ -4875,11 +11255,11 @@
 
 } // namespace ContentLaunchDimension
 namespace ContentLaunchStyleInformation {
-enum FieldId
+enum class Fields
 {
-    kImageUrlFieldId = 0,
-    kColorFieldId    = 1,
-    kSizeFieldId     = 2,
+    kImageUrl = 0,
+    kColor    = 1,
+    kSize     = 2,
 };
 
 struct Type
@@ -4899,45 +11279,129 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LaunchContent
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LaunchContentResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LaunchURL
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LaunchURLResponse
+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 {
@@ -4953,11 +11417,11 @@
 };
 
 namespace AudioOutputInfo {
-enum FieldId
+enum class Fields
 {
-    kIndexFieldId      = 0,
-    kOutputTypeFieldId = 1,
-    kNameFieldId       = 2,
+    kIndex      = 0,
+    kOutputType = 1,
+    kName       = 2,
 };
 
 struct Type
@@ -4977,25 +11441,64 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace SelectOutput
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace RenameOutput
+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 {
@@ -5008,10 +11511,10 @@
 };
 
 namespace ApplicationLauncherApp {
-enum FieldId
+enum class Fields
 {
-    kCatalogVendorIdFieldId = 0,
-    kApplicationIdFieldId   = 1,
+    kCatalogVendorId = 0,
+    kApplicationId   = 1,
 };
 
 struct Type
@@ -5030,25 +11533,70 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LaunchApp
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LaunchAppResponse
+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 ApplicationLauncher
 namespace ApplicationBasic {
@@ -5063,50 +11611,125 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace ChangeStatus
+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 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetSetupPIN
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetSetupPINResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Login
+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 {
@@ -5120,13 +11743,13 @@
 };
 
 namespace SimpleStruct {
-enum FieldId
+enum class Fields
 {
-    kAFieldId = 0,
-    kBFieldId = 1,
-    kCFieldId = 2,
-    kDFieldId = 3,
-    kEFieldId = 4,
+    kA = 0,
+    kB = 1,
+    kC = 2,
+    kD = 3,
+    kE = 4,
 };
 
 struct Type
@@ -5146,11 +11769,11 @@
 
 } // namespace SimpleStruct
 namespace NestedStruct {
-enum FieldId
+enum class Fields
 {
-    kAFieldId = 0,
-    kBFieldId = 1,
-    kCFieldId = 2,
+    kA = 0,
+    kB = 1,
+    kC = 2,
 };
 
 struct Type
@@ -5168,15 +11791,15 @@
 
 } // namespace NestedStruct
 namespace NestedStructList {
-enum FieldId
+enum class Fields
 {
-    kAFieldId = 0,
-    kBFieldId = 1,
-    kCFieldId = 2,
-    kDFieldId = 3,
-    kEFieldId = 4,
-    kFFieldId = 5,
-    kGFieldId = 6,
+    kA = 0,
+    kB = 1,
+    kC = 2,
+    kD = 3,
+    kE = 4,
+    kF = 5,
+    kG = 6,
 };
 
 struct Type
@@ -5208,9 +11831,9 @@
 
 } // namespace NestedStructList
 namespace DoubleNestedStructList {
-enum FieldId
+enum class Fields
 {
-    kAFieldId = 0,
+    kA = 0,
 };
 
 struct Type
@@ -5230,10 +11853,10 @@
 
 } // namespace DoubleNestedStructList
 namespace TestListStructOctet {
-enum FieldId
+enum class Fields
 {
-    kFabricIndexFieldId     = 0,
-    kOperationalCertFieldId = 1,
+    kFabricIndex     = 0,
+    kOperationalCert = 1,
 };
 
 struct Type
@@ -5252,75 +11875,330 @@
 
 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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Test
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace TestSpecificResponse
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace TestNotHandled
+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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace TestAddArgumentsResponse
+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
+{
+};
+
 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; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace TestSpecific
+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
+{
+    kReturnValue = 0,
+};
+
+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; }
+
+    bool returnValue;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestSimpleArgumentResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    bool returnValue;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSimpleArgumentResponse
 namespace TestUnknownCommand {
+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 TestUnknownCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace TestUnknownCommand
+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<NestedStructList::Type> arg1;
+    DataModel::List<SimpleStruct::Type> arg2;
+    DataModel::List<SimpleEnum> arg3;
+    DataModel::List<bool> arg4;
+    SimpleEnum arg5;
+    bool arg6;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    DataModel::DecodableList<NestedStructList::DecodableType> arg1;
+    DataModel::DecodableList<SimpleStruct::DecodableType> arg2;
+    DataModel::DecodableList<SimpleEnum> arg3;
+    DataModel::DecodableList<bool> arg4;
+    SimpleEnum arg5;
+    bool arg6;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestStructArrayArgumentResponse
 namespace TestAddArguments {
+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;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace TestAddArguments
+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);
+};
+}; // 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, uint64_t 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<NestedStructList::Type> arg1;
+    DataModel::List<SimpleStruct::Type> arg2;
+    DataModel::List<SimpleEnum> arg3;
+    DataModel::List<bool> arg4;
+    SimpleEnum arg5;
+    bool arg6;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
+};
+
+struct DecodableType
+{
+public:
+    static constexpr CommandId GetCommandId() { return TestStructArrayArgumentRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return TestCluster::Id; }
+
+    DataModel::DecodableList<NestedStructList::DecodableType> arg1;
+    DataModel::DecodableList<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 TestCluster
 namespace Messaging {
@@ -5440,75 +12318,239 @@
 
 namespace Commands {
 namespace DisplayMessage {
+enum class Fields
+{
+    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 DisplayMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+
+    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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace DisplayMessage
+public:
+    static constexpr CommandId GetCommandId() { return DisplayMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::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);
+};
+}; // namespace DisplayMessage
 namespace GetLastMessage {
+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 GetLastMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetLastMessage
+public:
+    static constexpr CommandId GetCommandId() { return GetLastMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetLastMessage
 namespace CancelMessage {
+enum class Fields
+{
+    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 CancelMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+
+    uint32_t messageId;
+    uint8_t messageControl;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CancelMessage
+public:
+    static constexpr CommandId GetCommandId() { return CancelMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
+    uint32_t messageId;
+    uint8_t messageControl;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CancelMessage
 namespace MessageConfirmation {
+enum class Fields
+{
+    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 MessageConfirmation::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+
+    uint32_t messageId;
+    uint32_t confirmationTime;
+    uint8_t messageConfirmationControl;
+    chip::ByteSpan messageResponse;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace MessageConfirmation
+public:
+    static constexpr CommandId GetCommandId() { return MessageConfirmation::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
+    uint32_t messageId;
+    uint32_t confirmationTime;
+    uint8_t messageConfirmationControl;
+    chip::ByteSpan messageResponse;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MessageConfirmation
 namespace DisplayProtectedMessage {
+enum class Fields
+{
+    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 DisplayProtectedMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
+
+    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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace DisplayProtectedMessage
+public:
+    static constexpr CommandId GetCommandId() { return DisplayProtectedMessage::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::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);
+};
+}; // namespace DisplayProtectedMessage
 namespace GetMessageCancellation {
+enum class Fields
+{
+    kEarliestImplementationTime = 0,
+};
+
 struct Type
 {
+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; }
+
+    uint32_t earliestImplementationTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetMessageCancellation
+public:
+    static constexpr CommandId GetCommandId() { return GetMessageCancellation::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
+    uint32_t earliestImplementationTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetMessageCancellation
 namespace CancelAllMessages {
+enum class Fields
+{
+    kImplementationDateTime = 0,
+};
+
 struct Type
 {
+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; }
+
+    uint32_t implementationDateTime;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CancelAllMessages
+public:
+    static constexpr CommandId GetCommandId() { return CancelAllMessages::Id; }
+    static constexpr ClusterId GetClusterId() { return Messaging::Id; }
 
+    uint32_t implementationDateTime;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CancelAllMessages
 } // namespace Commands
 } // namespace Messaging
 namespace ApplianceIdentification {
@@ -5530,180 +12572,531 @@
 
 namespace Commands {
 namespace GetAlerts {
+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 GetAlerts::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetAlerts
+public:
+    static constexpr CommandId GetCommandId() { return GetAlerts::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetAlerts
 namespace GetAlertsResponse {
+enum class Fields
+{
+    kAlertsCount = 0,
+};
+
 struct Type
 {
+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; }
+
+    uint8_t alertsCount;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetAlertsResponse
+public:
+    static constexpr CommandId GetCommandId() { return GetAlertsResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
 
+    uint8_t alertsCount;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetAlertsResponse
 namespace AlertsNotification {
+enum class Fields
+{
+    kAlertsCount = 0,
+};
+
 struct Type
 {
+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; }
+
+    uint8_t alertsCount;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace AlertsNotification
+public:
+    static constexpr CommandId GetCommandId() { return AlertsNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
 
+    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 EventsNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceEventsAndAlert::Id; }
+
+    uint8_t eventHeader;
+    EventIdentification eventId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace EventsNotification
+public:
+    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 EventsNotification
 } // namespace Commands
 } // namespace ApplianceEventsAndAlert
 namespace ApplianceStatistics {
 
 namespace Commands {
 namespace LogNotification {
+enum class Fields
+{
+    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 LogNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+
+    uint32_t timeStamp;
+    uint32_t logId;
+    uint32_t logLength;
+    DataModel::List<uint8_t> logPayload;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LogNotification
+public:
+    static constexpr CommandId GetCommandId() { return LogNotification::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
+    uint32_t timeStamp;
+    uint32_t logId;
+    uint32_t logLength;
+    DataModel::DecodableList<uint8_t> logPayload;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 LogRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+
+    uint32_t logId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LogRequest
+public:
+    static constexpr CommandId GetCommandId() { return LogRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
+    uint32_t logId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LogRequest
 namespace LogResponse {
+enum class Fields
+{
+    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 LogResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+
+    uint32_t timeStamp;
+    uint32_t logId;
+    uint32_t logLength;
+    DataModel::List<uint8_t> logPayload;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LogResponse
+public:
+    static constexpr CommandId GetCommandId() { return LogResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
+    uint32_t timeStamp;
+    uint32_t logId;
+    uint32_t logLength;
+    DataModel::DecodableList<uint8_t> logPayload;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LogResponse
 namespace LogQueueRequest {
+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 LogQueueRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LogQueueRequest
+public:
+    static constexpr CommandId GetCommandId() { return LogQueueRequest::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LogQueueRequest
 namespace LogQueueResponse {
+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 LogQueueResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+
+    uint8_t logQueueSize;
+    DataModel::List<uint32_t> logIds;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace LogQueueResponse
+public:
+    static constexpr CommandId GetCommandId() { return LogQueueResponse::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
 
+    uint8_t logQueueSize;
+    DataModel::DecodableList<uint32_t> logIds;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // 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 StatisticsAvailable::Id; }
+    static constexpr ClusterId GetClusterId() { return ApplianceStatistics::Id; }
+
+    uint8_t logQueueSize;
+    DataModel::List<uint32_t> logIds;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace StatisticsAvailable
+public:
+    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 StatisticsAvailable
 } // namespace Commands
 } // namespace ApplianceStatistics
 namespace ElectricalMeasurement {
 
 namespace Commands {
 namespace GetProfileInfoResponseCommand {
+enum class Fields
+{
+    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 GetProfileInfoResponseCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+
+    uint8_t profileCount;
+    uint8_t profileIntervalPeriod;
+    uint8_t maxNumberOfIntervals;
+    DataModel::List<uint16_t> listOfAttributes;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetProfileInfoResponseCommand
+public:
+    static constexpr CommandId GetCommandId() { return GetProfileInfoResponseCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
+    uint8_t profileCount;
+    uint8_t profileIntervalPeriod;
+    uint8_t maxNumberOfIntervals;
+    DataModel::DecodableList<uint16_t> listOfAttributes;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetProfileInfoResponseCommand
 namespace GetProfileInfoCommand {
+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 GetProfileInfoCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetProfileInfoCommand
+public:
+    static constexpr CommandId GetCommandId() { return GetProfileInfoCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetProfileInfoCommand
 namespace GetMeasurementProfileResponseCommand {
+enum class Fields
+{
+    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 GetMeasurementProfileResponseCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+
+    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, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetMeasurementProfileResponseCommand
+public:
+    static constexpr CommandId GetCommandId() { return GetMeasurementProfileResponseCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::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);
+};
+}; // namespace GetMeasurementProfileResponseCommand
 namespace GetMeasurementProfileCommand {
+enum class Fields
+{
+    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 GetMeasurementProfileCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
+
+    uint16_t attributeId;
+    uint32_t startTime;
+    uint8_t numberOfIntervals;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace GetMeasurementProfileCommand
+public:
+    static constexpr CommandId GetCommandId() { return GetMeasurementProfileCommand::Id; }
+    static constexpr ClusterId GetClusterId() { return ElectricalMeasurement::Id; }
 
+    uint16_t attributeId;
+    uint32_t startTime;
+    uint8_t numberOfIntervals;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetMeasurementProfileCommand
 } // namespace Commands
 } // namespace ElectricalMeasurement
 namespace Binding {
 
 namespace Commands {
 namespace Bind {
+enum class Fields
+{
+    kNodeId     = 0,
+    kGroupId    = 1,
+    kEndpointId = 2,
+    kClusterId  = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Bind::Id; }
+    static constexpr ClusterId GetClusterId() { return Binding::Id; }
+
+    chip::NodeId nodeId;
+    chip::GroupId groupId;
+    chip::EndpointId endpointId;
+    chip::ClusterId clusterId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Bind
+public:
+    static constexpr CommandId GetCommandId() { return Bind::Id; }
+    static constexpr ClusterId GetClusterId() { return Binding::Id; }
 
+    chip::NodeId nodeId;
+    chip::GroupId groupId;
+    chip::EndpointId endpointId;
+    chip::ClusterId clusterId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Bind
 namespace Unbind {
+enum class Fields
+{
+    kNodeId     = 0,
+    kGroupId    = 1,
+    kEndpointId = 2,
+    kClusterId  = 3,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return Unbind::Id; }
+    static constexpr ClusterId GetClusterId() { return Binding::Id; }
+
+    chip::NodeId nodeId;
+    chip::GroupId groupId;
+    chip::EndpointId endpointId;
+    chip::ClusterId clusterId;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace Unbind
+public:
+    static constexpr CommandId GetCommandId() { return Unbind::Id; }
+    static constexpr ClusterId GetClusterId() { return Binding::Id; }
 
+    chip::NodeId nodeId;
+    chip::GroupId groupId;
+    chip::EndpointId endpointId;
+    chip::ClusterId clusterId;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Unbind
 } // namespace Commands
 } // namespace Binding
 namespace GroupKeyManagement {
@@ -5715,13 +13108,13 @@
 };
 
 namespace GroupKey {
-enum FieldId
+enum class Fields
 {
-    kVendorIdFieldId               = 0,
-    kGroupKeyIndexFieldId          = 1,
-    kGroupKeyRootFieldId           = 2,
-    kGroupKeyEpochStartTimeFieldId = 3,
-    kGroupKeySecurityPolicyFieldId = 4,
+    kVendorId               = 0,
+    kGroupKeyIndex          = 1,
+    kGroupKeyRoot           = 2,
+    kGroupKeyEpochStartTime = 3,
+    kGroupKeySecurityPolicy = 4,
 };
 
 struct Type
@@ -5741,11 +13134,11 @@
 
 } // namespace GroupKey
 namespace GroupState {
-enum FieldId
+enum class Fields
 {
-    kVendorIdFieldId         = 0,
-    kVendorGroupIdFieldId    = 1,
-    kGroupKeySetIndexFieldId = 2,
+    kVendorId         = 0,
+    kVendorGroupId    = 1,
+    kGroupKeySetIndex = 2,
 };
 
 struct Type
@@ -5768,30 +13161,66 @@
 
 namespace Commands {
 namespace CommandOne {
+enum class Fields
+{
+    kArgOne = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return CommandOne::Id; }
+    static constexpr ClusterId GetClusterId() { return SampleMfgSpecificCluster::Id; }
+
+    uint8_t argOne;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CommandOne
+public:
+    static constexpr CommandId GetCommandId() { return CommandOne::Id; }
+    static constexpr ClusterId GetClusterId() { return SampleMfgSpecificCluster::Id; }
 
+    uint8_t argOne;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CommandOne
 } // namespace Commands
 } // namespace SampleMfgSpecificCluster
 namespace SampleMfgSpecificCluster2 {
 
 namespace Commands {
 namespace CommandTwo {
+enum class Fields
+{
+    kArgOne = 0,
+};
+
 struct Type
 {
+public:
+    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+    static constexpr CommandId GetCommandId() { return CommandTwo::Id; }
+    static constexpr ClusterId GetClusterId() { return SampleMfgSpecificCluster2::Id; }
+
+    uint8_t argOne;
+
+    CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const;
 };
 
 struct DecodableType
 {
-};
-} // namespace CommandTwo
+public:
+    static constexpr CommandId GetCommandId() { return CommandTwo::Id; }
+    static constexpr ClusterId GetClusterId() { return SampleMfgSpecificCluster2::Id; }
 
+    uint8_t argOne;
+    CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CommandTwo
 } // namespace Commands
 } // namespace SampleMfgSpecificCluster2
 
diff --git a/zzz_generated/app-common/app-common/zap-generated/command-id.h b/zzz_generated/app-common/app-common/zap-generated/command-id.h
index a4a8634..b7d5ef5 100644
--- a/zzz_generated/app-common/app-common/zap-generated/command-id.h
+++ b/zzz_generated/app-common/app-common/zap-generated/command-id.h
@@ -448,8 +448,12 @@
 #define ZCL_TEST_NOT_HANDLED_COMMAND_ID (0x01)
 #define ZCL_TEST_ADD_ARGUMENTS_RESPONSE_COMMAND_ID (0x01)
 #define ZCL_TEST_SPECIFIC_COMMAND_ID (0x02)
+#define ZCL_TEST_SIMPLE_ARGUMENT_RESPONSE_COMMAND_ID (0x02)
 #define ZCL_TEST_UNKNOWN_COMMAND_COMMAND_ID (0x03)
+#define ZCL_TEST_STRUCT_ARRAY_ARGUMENT_RESPONSE_COMMAND_ID (0x03)
 #define ZCL_TEST_ADD_ARGUMENTS_COMMAND_ID (0x04)
+#define ZCL_TEST_SIMPLE_ARGUMENT_REQUEST_COMMAND_ID (0x05)
+#define ZCL_TEST_STRUCT_ARRAY_ARGUMENT_REQUEST_COMMAND_ID (0x06)
 
 // Commands for cluster: Messaging
 #define ZCL_DISPLAY_MESSAGE_COMMAND_ID (0x00)
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
index fe88151..3664809 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
@@ -1556,14 +1556,30 @@
 static constexpr CommandId Id = 0x00000002;
 } // namespace TestSpecific
 
+namespace TestSimpleArgumentResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace TestSimpleArgumentResponse
+
 namespace TestUnknownCommand {
 static constexpr CommandId Id = 0x00000003;
 } // namespace TestUnknownCommand
 
+namespace TestStructArrayArgumentResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace TestStructArrayArgumentResponse
+
 namespace TestAddArguments {
 static constexpr CommandId Id = 0x00000004;
 } // namespace TestAddArguments
 
+namespace TestSimpleArgumentRequest {
+static constexpr CommandId Id = 0x00000005;
+} // namespace TestSimpleArgumentRequest
+
+namespace TestStructArrayArgumentRequest {
+static constexpr CommandId Id = 0x00000006;
+} // namespace TestStructArrayArgumentRequest
+
 } // namespace Commands
 } // namespace TestCluster