diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
index b8fd559dd8641a..7f9a44937b7489 100644
--- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
+++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
@@ -14010,69 +14010,6 @@ - (void)testSendClusterTestCluster_000105_WriteAttribute
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
 - (void)testSendClusterTestCluster_000106_ReadAttribute
-{
-    XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST"];
-
-    CHIPDevice * device = GetConnectedDevice();
-    dispatch_queue_t queue = dispatch_get_main_queue();
-    CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue];
-    XCTAssertNotNil(cluster);
-
-    [cluster readAttributeListInt8uWithResponseHandler:^(NSError * err, NSDictionary * values) {
-        NSLog(@"Read attribute LIST Error: %@", err);
-
-        XCTAssertEqual(err.code, 0);
-
-        XCTAssertEqual([values[@"value"] count], 4);
-
-        [expectation fulfill];
-    }];
-
-    [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
-}
-- (void)testSendClusterTestCluster_000107_ReadAttribute
-{
-    XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST_OCTET_STRING"];
-
-    CHIPDevice * device = GetConnectedDevice();
-    dispatch_queue_t queue = dispatch_get_main_queue();
-    CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue];
-    XCTAssertNotNil(cluster);
-
-    [cluster readAttributeListOctetStringWithResponseHandler:^(NSError * err, NSDictionary * values) {
-        NSLog(@"Read attribute LIST_OCTET_STRING Error: %@", err);
-
-        XCTAssertEqual(err.code, 0);
-
-        XCTAssertEqual([values[@"value"] count], 4);
-
-        [expectation fulfill];
-    }];
-
-    [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
-}
-- (void)testSendClusterTestCluster_000108_ReadAttribute
-{
-    XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST_STRUCT_OCTET_STRING"];
-
-    CHIPDevice * device = GetConnectedDevice();
-    dispatch_queue_t queue = dispatch_get_main_queue();
-    CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue];
-    XCTAssertNotNil(cluster);
-
-    [cluster readAttributeListStructOctetStringWithResponseHandler:^(NSError * err, NSDictionary * values) {
-        NSLog(@"Read attribute LIST_STRUCT_OCTET_STRING Error: %@", err);
-
-        XCTAssertEqual(err.code, 0);
-
-        XCTAssertEqual([values[@"value"] count], 4);
-
-        [expectation fulfill];
-    }];
-
-    [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
-}
-- (void)testSendClusterTestCluster_000109_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Default Value"];
 
@@ -14093,7 +14030,7 @@ - (void)testSendClusterTestCluster_000109_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000110_WriteAttribute
+- (void)testSendClusterTestCluster_000107_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Max Value"];
 
@@ -14114,7 +14051,7 @@ - (void)testSendClusterTestCluster_000110_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000111_ReadAttribute
+- (void)testSendClusterTestCluster_000108_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Max Value"];
 
@@ -14135,7 +14072,7 @@ - (void)testSendClusterTestCluster_000111_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000112_WriteAttribute
+- (void)testSendClusterTestCluster_000109_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Min Value"];
 
@@ -14156,7 +14093,7 @@ - (void)testSendClusterTestCluster_000112_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000113_ReadAttribute
+- (void)testSendClusterTestCluster_000110_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Min Value"];
 
@@ -14177,7 +14114,7 @@ - (void)testSendClusterTestCluster_000113_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000114_ReadAttribute
+- (void)testSendClusterTestCluster_000111_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Default Value"];
 
@@ -14198,7 +14135,7 @@ - (void)testSendClusterTestCluster_000114_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000115_WriteAttribute
+- (void)testSendClusterTestCluster_000112_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Max Value"];
 
@@ -14219,7 +14156,7 @@ - (void)testSendClusterTestCluster_000115_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000116_ReadAttribute
+- (void)testSendClusterTestCluster_000113_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Max Value"];
 
@@ -14240,7 +14177,7 @@ - (void)testSendClusterTestCluster_000116_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000117_WriteAttribute
+- (void)testSendClusterTestCluster_000114_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Min Value"];
 
@@ -14261,7 +14198,7 @@ - (void)testSendClusterTestCluster_000117_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000118_ReadAttribute
+- (void)testSendClusterTestCluster_000115_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Min Value"];
 
@@ -14282,7 +14219,7 @@ - (void)testSendClusterTestCluster_000118_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000119_ReadAttribute
+- (void)testSendClusterTestCluster_000116_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute UNSUPPORTED"];
 
@@ -14308,7 +14245,7 @@ - (void)testSendClusterTestCluster_000119_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000120_WriteAttribute
+- (void)testSendClusterTestCluster_000117_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Writeattribute UNSUPPORTED"];
 
@@ -14334,7 +14271,7 @@ - (void)testSendClusterTestCluster_000120_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000121_Test
+- (void)testSendClusterTestCluster_000118_Test
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command to unsupported endpoint"];
 
@@ -14352,7 +14289,7 @@ - (void)testSendClusterTestCluster_000121_Test
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000122_ReadAttribute
+- (void)testSendClusterTestCluster_000119_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id Default Value"];
 
@@ -14373,7 +14310,7 @@ - (void)testSendClusterTestCluster_000122_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000123_WriteAttribute
+- (void)testSendClusterTestCluster_000120_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute vendor_id"];
 
@@ -14394,7 +14331,7 @@ - (void)testSendClusterTestCluster_000123_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000124_ReadAttribute
+- (void)testSendClusterTestCluster_000121_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id"];
 
@@ -14415,7 +14352,7 @@ - (void)testSendClusterTestCluster_000124_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000125_WriteAttribute
+- (void)testSendClusterTestCluster_000122_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Restore attribute vendor_id"];
 
@@ -14436,7 +14373,7 @@ - (void)testSendClusterTestCluster_000125_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000126_TestEnumsRequest
+- (void)testSendClusterTestCluster_000123_TestEnumsRequest
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command with a vendor_id and enum"];
 
diff --git a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h
index fff1319ed8f4fd..367ae229b4c58c 100644
--- a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h
+++ b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h
@@ -1450,7 +1450,7 @@
             /* Endpoint: 1, Cluster: Thermostat (server), little-endian */                                                         \
                                                                                                                                    \
             /* 3557 - FeatureMap, */                                                                                               \
-            0x0B, 0x00, 0x00, 0x00,                                                                                                \
+            0x00, 0x00, 0x00, 0x0B,                                                                                                \
                                                                                                                                    \
             /* Endpoint: 1, Cluster: Color Control (server), little-endian */                                                      \
                                                                                                                                    \
@@ -1528,7 +1528,7 @@
             /* Endpoint: 1, Cluster: Media Playback (server), little-endian */                                                     \
                                                                                                                                    \
             /* 4431 - start time, */                                                                                               \
-            0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,                                                                        \
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,                                                                        \
                                                                                                                                    \
             /* 4439 - duration, */                                                                                                 \
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,                                                                        \
@@ -2349,12 +2349,12 @@
             { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(3) }, /* ClusterRevision */                                       \
                                                                                                                                    \
             /* Endpoint: 1, Cluster: Illuminance Measurement (server) */                                                           \
-            { 0x0000, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(NULLABLE), ZAP_SIMPLE_DEFAULT(0x0000) }, /* MeasuredValue */         \
-            { 0x0001, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(NULLABLE), ZAP_EMPTY_DEFAULT() },        /* MinMeasuredValue */      \
-            { 0x0002, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(NULLABLE), ZAP_EMPTY_DEFAULT() },        /* MaxMeasuredValue */      \
-            { 0x0003, ZAP_TYPE(INT16U), 2, 0, ZAP_EMPTY_DEFAULT() },                                   /* Tolerance */             \
-            { 0x0004, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(NULLABLE), ZAP_SIMPLE_DEFAULT(0xFF) },    /* LightSensorType */       \
-            { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(2) },                                 /* ClusterRevision */       \
+            { 0x0000, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0000) }, /* MeasuredValue */                                    \
+            { 0x0001, ZAP_TYPE(INT16U), 2, 0, ZAP_EMPTY_DEFAULT() },        /* MinMeasuredValue */                                 \
+            { 0x0002, ZAP_TYPE(INT16U), 2, 0, ZAP_EMPTY_DEFAULT() },        /* MaxMeasuredValue */                                 \
+            { 0x0003, ZAP_TYPE(INT16U), 2, 0, ZAP_EMPTY_DEFAULT() },        /* Tolerance */                                        \
+            { 0x0004, ZAP_TYPE(ENUM8), 1, 0, ZAP_SIMPLE_DEFAULT(0xFF) },    /* LightSensorType */                                  \
+            { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(2) },      /* ClusterRevision */                                  \
                                                                                                                                    \
             /* Endpoint: 1, Cluster: Temperature Measurement (server) */                                                           \
             { 0x0000, ZAP_TYPE(INT16S), 2, 0, ZAP_SIMPLE_DEFAULT(0x8000) }, /* MeasuredValue */                                    \
diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h
index 1d624d64a8849d..7dcceff2e9517f 100644
--- a/zzz_generated/chip-tool/zap-generated/test/Commands.h
+++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h
@@ -22463,88 +22463,76 @@ class TestCluster : public TestCommand
             err = TestWriteAttributeLongCharString_105();
             break;
         case 106:
-            ChipLogProgress(chipTool, " ***** Test Step 106 : Read attribute LIST\n");
-            err = TestReadAttributeList_106();
+            ChipLogProgress(chipTool, " ***** Test Step 106 : Read attribute EPOCH_US Default Value\n");
+            err = TestReadAttributeEpochUsDefaultValue_106();
             break;
         case 107:
-            ChipLogProgress(chipTool, " ***** Test Step 107 : Read attribute LIST_OCTET_STRING\n");
-            err = TestReadAttributeListOctetString_107();
+            ChipLogProgress(chipTool, " ***** Test Step 107 : Write attribute EPOCH_US Max Value\n");
+            err = TestWriteAttributeEpochUsMaxValue_107();
             break;
         case 108:
-            ChipLogProgress(chipTool, " ***** Test Step 108 : Read attribute LIST_STRUCT_OCTET_STRING\n");
-            err = TestReadAttributeListStructOctetString_108();
+            ChipLogProgress(chipTool, " ***** Test Step 108 : Read attribute EPOCH_US Max Value\n");
+            err = TestReadAttributeEpochUsMaxValue_108();
             break;
         case 109:
-            ChipLogProgress(chipTool, " ***** Test Step 109 : Read attribute EPOCH_US Default Value\n");
-            err = TestReadAttributeEpochUsDefaultValue_109();
+            ChipLogProgress(chipTool, " ***** Test Step 109 : Write attribute EPOCH_US Min Value\n");
+            err = TestWriteAttributeEpochUsMinValue_109();
             break;
         case 110:
-            ChipLogProgress(chipTool, " ***** Test Step 110 : Write attribute EPOCH_US Max Value\n");
-            err = TestWriteAttributeEpochUsMaxValue_110();
+            ChipLogProgress(chipTool, " ***** Test Step 110 : Read attribute EPOCH_US Min Value\n");
+            err = TestReadAttributeEpochUsMinValue_110();
             break;
         case 111:
-            ChipLogProgress(chipTool, " ***** Test Step 111 : Read attribute EPOCH_US Max Value\n");
-            err = TestReadAttributeEpochUsMaxValue_111();
+            ChipLogProgress(chipTool, " ***** Test Step 111 : Read attribute EPOCH_S Default Value\n");
+            err = TestReadAttributeEpochSDefaultValue_111();
             break;
         case 112:
-            ChipLogProgress(chipTool, " ***** Test Step 112 : Write attribute EPOCH_US Min Value\n");
-            err = TestWriteAttributeEpochUsMinValue_112();
+            ChipLogProgress(chipTool, " ***** Test Step 112 : Write attribute EPOCH_S Max Value\n");
+            err = TestWriteAttributeEpochSMaxValue_112();
             break;
         case 113:
-            ChipLogProgress(chipTool, " ***** Test Step 113 : Read attribute EPOCH_US Min Value\n");
-            err = TestReadAttributeEpochUsMinValue_113();
+            ChipLogProgress(chipTool, " ***** Test Step 113 : Read attribute EPOCH_S Max Value\n");
+            err = TestReadAttributeEpochSMaxValue_113();
             break;
         case 114:
-            ChipLogProgress(chipTool, " ***** Test Step 114 : Read attribute EPOCH_S Default Value\n");
-            err = TestReadAttributeEpochSDefaultValue_114();
+            ChipLogProgress(chipTool, " ***** Test Step 114 : Write attribute EPOCH_S Min Value\n");
+            err = TestWriteAttributeEpochSMinValue_114();
             break;
         case 115:
-            ChipLogProgress(chipTool, " ***** Test Step 115 : Write attribute EPOCH_S Max Value\n");
-            err = TestWriteAttributeEpochSMaxValue_115();
+            ChipLogProgress(chipTool, " ***** Test Step 115 : Read attribute EPOCH_S Min Value\n");
+            err = TestReadAttributeEpochSMinValue_115();
             break;
         case 116:
-            ChipLogProgress(chipTool, " ***** Test Step 116 : Read attribute EPOCH_S Max Value\n");
-            err = TestReadAttributeEpochSMaxValue_116();
+            ChipLogProgress(chipTool, " ***** Test Step 116 : Read attribute UNSUPPORTED\n");
+            err = TestReadAttributeUnsupported_116();
             break;
         case 117:
-            ChipLogProgress(chipTool, " ***** Test Step 117 : Write attribute EPOCH_S Min Value\n");
-            err = TestWriteAttributeEpochSMinValue_117();
+            ChipLogProgress(chipTool, " ***** Test Step 117 : Writeattribute UNSUPPORTED\n");
+            err = TestWriteattributeUnsupported_117();
             break;
         case 118:
-            ChipLogProgress(chipTool, " ***** Test Step 118 : Read attribute EPOCH_S Min Value\n");
-            err = TestReadAttributeEpochSMinValue_118();
+            ChipLogProgress(chipTool, " ***** Test Step 118 : Send Test Command to unsupported endpoint\n");
+            err = TestSendTestCommandToUnsupportedEndpoint_118();
             break;
         case 119:
-            ChipLogProgress(chipTool, " ***** Test Step 119 : Read attribute UNSUPPORTED\n");
-            err = TestReadAttributeUnsupported_119();
+            ChipLogProgress(chipTool, " ***** Test Step 119 : Read attribute vendor_id Default Value\n");
+            err = TestReadAttributeVendorIdDefaultValue_119();
             break;
         case 120:
-            ChipLogProgress(chipTool, " ***** Test Step 120 : Writeattribute UNSUPPORTED\n");
-            err = TestWriteattributeUnsupported_120();
+            ChipLogProgress(chipTool, " ***** Test Step 120 : Write attribute vendor_id\n");
+            err = TestWriteAttributeVendorId_120();
             break;
         case 121:
-            ChipLogProgress(chipTool, " ***** Test Step 121 : Send Test Command to unsupported endpoint\n");
-            err = TestSendTestCommandToUnsupportedEndpoint_121();
+            ChipLogProgress(chipTool, " ***** Test Step 121 : Read attribute vendor_id\n");
+            err = TestReadAttributeVendorId_121();
             break;
         case 122:
-            ChipLogProgress(chipTool, " ***** Test Step 122 : Read attribute vendor_id Default Value\n");
-            err = TestReadAttributeVendorIdDefaultValue_122();
+            ChipLogProgress(chipTool, " ***** Test Step 122 : Restore attribute vendor_id\n");
+            err = TestRestoreAttributeVendorId_122();
             break;
         case 123:
-            ChipLogProgress(chipTool, " ***** Test Step 123 : Write attribute vendor_id\n");
-            err = TestWriteAttributeVendorId_123();
-            break;
-        case 124:
-            ChipLogProgress(chipTool, " ***** Test Step 124 : Read attribute vendor_id\n");
-            err = TestReadAttributeVendorId_124();
-            break;
-        case 125:
-            ChipLogProgress(chipTool, " ***** Test Step 125 : Restore attribute vendor_id\n");
-            err = TestRestoreAttributeVendorId_125();
-            break;
-        case 126:
-            ChipLogProgress(chipTool, " ***** Test Step 126 : Send a command with a vendor_id and enum\n");
-            err = TestSendACommandWithAVendorIdAndEnum_126();
+            ChipLogProgress(chipTool, " ***** Test Step 123 : Send a command with a vendor_id and enum\n");
+            err = TestSendACommandWithAVendorIdAndEnum_123();
             break;
         }
 
@@ -22557,7 +22545,7 @@ class TestCluster : public TestCommand
 
 private:
     std::atomic_uint16_t mTestIndex;
-    const uint16_t mTestCount = 127;
+    const uint16_t mTestCount = 124;
 
     chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_5{ OnFailureCallback_5, this };
     chip::Callback::Callback<void (*)(void * context, bool boolean)> mOnSuccessCallback_5{ OnSuccessCallback_5, this };
@@ -22682,36 +22670,24 @@ class TestCluster : public TestCommand
     chip::Callback::Callback<void (*)(void * context, chip::CharSpan longCharString)> mOnSuccessCallback_104{ OnSuccessCallback_104,
                                                                                                               this };
     chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_106{ OnFailureCallback_106, this };
-    chip::Callback::Callback<void (*)(void * context, const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)>
-        mOnSuccessCallback_106{ OnSuccessCallback_106, this };
-    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_107{ OnFailureCallback_107, this };
-    chip::Callback::Callback<void (*)(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)>
-        mOnSuccessCallback_107{ OnSuccessCallback_107, this };
+    chip::Callback::Callback<void (*)(void * context, uint64_t epochUs)> mOnSuccessCallback_106{ OnSuccessCallback_106, this };
     chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_108{ OnFailureCallback_108, this };
-    chip::Callback::Callback<void (*)(
-        void * context,
-        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
-            listStructOctetString)>
-        mOnSuccessCallback_108{ OnSuccessCallback_108, this };
-    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_109{ OnFailureCallback_109, this };
-    chip::Callback::Callback<void (*)(void * context, uint64_t epochUs)> mOnSuccessCallback_109{ OnSuccessCallback_109, this };
+    chip::Callback::Callback<void (*)(void * context, uint64_t epochUs)> mOnSuccessCallback_108{ OnSuccessCallback_108, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_110{ OnFailureCallback_110, this };
+    chip::Callback::Callback<void (*)(void * context, uint64_t epochUs)> mOnSuccessCallback_110{ OnSuccessCallback_110, this };
     chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_111{ OnFailureCallback_111, this };
-    chip::Callback::Callback<void (*)(void * context, uint64_t epochUs)> mOnSuccessCallback_111{ OnSuccessCallback_111, this };
+    chip::Callback::Callback<void (*)(void * context, uint32_t epochS)> mOnSuccessCallback_111{ OnSuccessCallback_111, this };
     chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_113{ OnFailureCallback_113, this };
-    chip::Callback::Callback<void (*)(void * context, uint64_t epochUs)> mOnSuccessCallback_113{ OnSuccessCallback_113, this };
-    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_114{ OnFailureCallback_114, this };
-    chip::Callback::Callback<void (*)(void * context, uint32_t epochS)> mOnSuccessCallback_114{ OnSuccessCallback_114, this };
+    chip::Callback::Callback<void (*)(void * context, uint32_t epochS)> mOnSuccessCallback_113{ OnSuccessCallback_113, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_115{ OnFailureCallback_115, this };
+    chip::Callback::Callback<void (*)(void * context, uint32_t epochS)> mOnSuccessCallback_115{ OnSuccessCallback_115, this };
     chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_116{ OnFailureCallback_116, this };
-    chip::Callback::Callback<void (*)(void * context, uint32_t epochS)> mOnSuccessCallback_116{ OnSuccessCallback_116, this };
-    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_118{ OnFailureCallback_118, this };
-    chip::Callback::Callback<void (*)(void * context, uint32_t epochS)> mOnSuccessCallback_118{ OnSuccessCallback_118, this };
+    chip::Callback::Callback<void (*)(void * context, bool unsupported)> mOnSuccessCallback_116{ OnSuccessCallback_116, this };
     chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_119{ OnFailureCallback_119, this };
-    chip::Callback::Callback<void (*)(void * context, bool unsupported)> mOnSuccessCallback_119{ OnSuccessCallback_119, this };
-    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_122{ OnFailureCallback_122, this };
-    chip::Callback::Callback<void (*)(void * context, chip::VendorId vendorId)> mOnSuccessCallback_122{ OnSuccessCallback_122,
+    chip::Callback::Callback<void (*)(void * context, chip::VendorId vendorId)> mOnSuccessCallback_119{ OnSuccessCallback_119,
                                                                                                         this };
-    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_124{ OnFailureCallback_124, this };
-    chip::Callback::Callback<void (*)(void * context, chip::VendorId vendorId)> mOnSuccessCallback_124{ OnSuccessCallback_124,
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_121{ OnFailureCallback_121, this };
+    chip::Callback::Callback<void (*)(void * context, chip::VendorId vendorId)> mOnSuccessCallback_121{ OnSuccessCallback_121,
                                                                                                         this };
 
     static void OnFailureCallback_5(void * context, uint8_t status)
@@ -23597,59 +23573,53 @@ class TestCluster : public TestCommand
         (static_cast<TestCluster *>(context))->OnFailureResponse_106(status);
     }
 
-    static void OnSuccessCallback_106(void * context, const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)
+    static void OnSuccessCallback_106(void * context, uint64_t epochUs)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_106(listInt8u);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_106(epochUs);
     }
 
-    static void OnFailureCallback_107(void * context, uint8_t status)
+    static void OnFailureCallback_107(void * context, EmberAfStatus status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_107(status);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_107(chip::to_underlying(status));
     }
 
-    static void OnSuccessCallback_107(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)
-    {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_107(listOctetString);
-    }
+    static void OnSuccessCallback_107(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_107(); }
 
     static void OnFailureCallback_108(void * context, uint8_t status)
     {
         (static_cast<TestCluster *>(context))->OnFailureResponse_108(status);
     }
 
-    static void OnSuccessCallback_108(
-        void * context,
-        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
-            listStructOctetString)
+    static void OnSuccessCallback_108(void * context, uint64_t epochUs)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_108(listStructOctetString);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_108(epochUs);
     }
 
-    static void OnFailureCallback_109(void * context, uint8_t status)
+    static void OnFailureCallback_109(void * context, EmberAfStatus status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_109(status);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_109(chip::to_underlying(status));
     }
 
-    static void OnSuccessCallback_109(void * context, uint64_t epochUs)
+    static void OnSuccessCallback_109(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_109(); }
+
+    static void OnFailureCallback_110(void * context, uint8_t status)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_109(epochUs);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_110(status);
     }
 
-    static void OnFailureCallback_110(void * context, EmberAfStatus status)
+    static void OnSuccessCallback_110(void * context, uint64_t epochUs)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_110(chip::to_underlying(status));
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_110(epochUs);
     }
 
-    static void OnSuccessCallback_110(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_110(); }
-
     static void OnFailureCallback_111(void * context, uint8_t status)
     {
         (static_cast<TestCluster *>(context))->OnFailureResponse_111(status);
     }
 
-    static void OnSuccessCallback_111(void * context, uint64_t epochUs)
+    static void OnSuccessCallback_111(void * context, uint32_t epochS)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_111(epochUs);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_111(epochS);
     }
 
     static void OnFailureCallback_112(void * context, EmberAfStatus status)
@@ -23664,36 +23634,36 @@ class TestCluster : public TestCommand
         (static_cast<TestCluster *>(context))->OnFailureResponse_113(status);
     }
 
-    static void OnSuccessCallback_113(void * context, uint64_t epochUs)
+    static void OnSuccessCallback_113(void * context, uint32_t epochS)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_113(epochUs);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_113(epochS);
     }
 
-    static void OnFailureCallback_114(void * context, uint8_t status)
+    static void OnFailureCallback_114(void * context, EmberAfStatus status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_114(status);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_114(chip::to_underlying(status));
     }
 
-    static void OnSuccessCallback_114(void * context, uint32_t epochS)
+    static void OnSuccessCallback_114(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_114(); }
+
+    static void OnFailureCallback_115(void * context, uint8_t status)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_114(epochS);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_115(status);
     }
 
-    static void OnFailureCallback_115(void * context, EmberAfStatus status)
+    static void OnSuccessCallback_115(void * context, uint32_t epochS)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_115(chip::to_underlying(status));
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_115(epochS);
     }
 
-    static void OnSuccessCallback_115(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_115(); }
-
     static void OnFailureCallback_116(void * context, uint8_t status)
     {
         (static_cast<TestCluster *>(context))->OnFailureResponse_116(status);
     }
 
-    static void OnSuccessCallback_116(void * context, uint32_t epochS)
+    static void OnSuccessCallback_116(void * context, bool unsupported)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_116(epochS);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_116(unsupported);
     }
 
     static void OnFailureCallback_117(void * context, EmberAfStatus status)
@@ -23703,24 +23673,14 @@ class TestCluster : public TestCommand
 
     static void OnSuccessCallback_117(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_117(); }
 
-    static void OnFailureCallback_118(void * context, uint8_t status)
-    {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_118(status);
-    }
-
-    static void OnSuccessCallback_118(void * context, uint32_t epochS)
-    {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_118(epochS);
-    }
-
     static void OnFailureCallback_119(void * context, uint8_t status)
     {
         (static_cast<TestCluster *>(context))->OnFailureResponse_119(status);
     }
 
-    static void OnSuccessCallback_119(void * context, bool unsupported)
+    static void OnSuccessCallback_119(void * context, chip::VendorId vendorId)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_119(unsupported);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_119(vendorId);
     }
 
     static void OnFailureCallback_120(void * context, EmberAfStatus status)
@@ -23730,39 +23690,22 @@ class TestCluster : public TestCommand
 
     static void OnSuccessCallback_120(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_120(); }
 
-    static void OnFailureCallback_122(void * context, uint8_t status)
-    {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_122(status);
-    }
-
-    static void OnSuccessCallback_122(void * context, chip::VendorId vendorId)
-    {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_122(vendorId);
-    }
-
-    static void OnFailureCallback_123(void * context, EmberAfStatus status)
-    {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_123(chip::to_underlying(status));
-    }
-
-    static void OnSuccessCallback_123(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_123(); }
-
-    static void OnFailureCallback_124(void * context, uint8_t status)
+    static void OnFailureCallback_121(void * context, uint8_t status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_124(status);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_121(status);
     }
 
-    static void OnSuccessCallback_124(void * context, chip::VendorId vendorId)
+    static void OnSuccessCallback_121(void * context, chip::VendorId vendorId)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_124(vendorId);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_121(vendorId);
     }
 
-    static void OnFailureCallback_125(void * context, EmberAfStatus status)
+    static void OnFailureCallback_122(void * context, EmberAfStatus status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_125(chip::to_underlying(status));
+        (static_cast<TestCluster *>(context))->OnFailureResponse_122(chip::to_underlying(status));
     }
 
-    static void OnSuccessCallback_125(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_125(); }
+    static void OnSuccessCallback_122(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_122(); }
 
     //
     // Tests methods
@@ -25538,73 +25481,23 @@ class TestCluster : public TestCommand
 
     void OnSuccessResponse_105() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeList_106()
+    CHIP_ERROR TestReadAttributeEpochUsDefaultValue_106()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeListInt8u(mOnSuccessCallback_106.Cancel(), mOnFailureCallback_106.Cancel());
+        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_106.Cancel(), mOnFailureCallback_106.Cancel());
     }
 
     void OnFailureResponse_106(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_106(const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)
-    {
-        VerifyOrReturn(CheckValueAsListLength("listInt8u", listInt8u, 4));
-        NextTest();
-    }
-
-    CHIP_ERROR TestReadAttributeListOctetString_107()
-    {
-        chip::Controller::TestClusterClusterTest cluster;
-        cluster.Associate(mDevice, 1);
-
-        return cluster.ReadAttributeListOctetString(mOnSuccessCallback_107.Cancel(), mOnFailureCallback_107.Cancel());
-    }
-
-    void OnFailureResponse_107(uint8_t status) { ThrowFailureResponse(); }
-
-    void OnSuccessResponse_107(const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)
-    {
-        VerifyOrReturn(CheckValueAsListLength("listOctetString", listOctetString, 4));
-        NextTest();
-    }
-
-    CHIP_ERROR TestReadAttributeListStructOctetString_108()
-    {
-        chip::Controller::TestClusterClusterTest cluster;
-        cluster.Associate(mDevice, 1);
-
-        return cluster.ReadAttributeListStructOctetString(mOnSuccessCallback_108.Cancel(), mOnFailureCallback_108.Cancel());
-    }
-
-    void OnFailureResponse_108(uint8_t status) { ThrowFailureResponse(); }
-
-    void OnSuccessResponse_108(
-        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
-            listStructOctetString)
-    {
-        VerifyOrReturn(CheckValueAsListLength("listStructOctetString", listStructOctetString, 4));
-        NextTest();
-    }
-
-    CHIP_ERROR TestReadAttributeEpochUsDefaultValue_109()
-    {
-        chip::Controller::TestClusterClusterTest cluster;
-        cluster.Associate(mDevice, 1);
-
-        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_109.Cancel(), mOnFailureCallback_109.Cancel());
-    }
-
-    void OnFailureResponse_109(uint8_t status) { ThrowFailureResponse(); }
-
-    void OnSuccessResponse_109(uint64_t epochUs)
+    void OnSuccessResponse_106(uint64_t epochUs)
     {
         VerifyOrReturn(CheckValue<uint64_t>("epochUs", epochUs, 0ULL));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeEpochUsMaxValue_110()
+    CHIP_ERROR TestWriteAttributeEpochUsMaxValue_107()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25613,30 +25506,30 @@ class TestCluster : public TestCommand
         epochUsArgument = 18446744073709551615ULL;
 
         return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::EpochUs::TypeInfo>(
-            epochUsArgument, this, OnSuccessCallback_110, OnFailureCallback_110);
+            epochUsArgument, this, OnSuccessCallback_107, OnFailureCallback_107);
     }
 
-    void OnFailureResponse_110(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_107(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_110() { NextTest(); }
+    void OnSuccessResponse_107() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeEpochUsMaxValue_111()
+    CHIP_ERROR TestReadAttributeEpochUsMaxValue_108()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_111.Cancel(), mOnFailureCallback_111.Cancel());
+        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_108.Cancel(), mOnFailureCallback_108.Cancel());
     }
 
-    void OnFailureResponse_111(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_108(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_111(uint64_t epochUs)
+    void OnSuccessResponse_108(uint64_t epochUs)
     {
         VerifyOrReturn(CheckValue<uint64_t>("epochUs", epochUs, 18446744073709551615ULL));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeEpochUsMinValue_112()
+    CHIP_ERROR TestWriteAttributeEpochUsMinValue_109()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25645,46 +25538,46 @@ class TestCluster : public TestCommand
         epochUsArgument = 0ULL;
 
         return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::EpochUs::TypeInfo>(
-            epochUsArgument, this, OnSuccessCallback_112, OnFailureCallback_112);
+            epochUsArgument, this, OnSuccessCallback_109, OnFailureCallback_109);
     }
 
-    void OnFailureResponse_112(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_109(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_112() { NextTest(); }
+    void OnSuccessResponse_109() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeEpochUsMinValue_113()
+    CHIP_ERROR TestReadAttributeEpochUsMinValue_110()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_113.Cancel(), mOnFailureCallback_113.Cancel());
+        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_110.Cancel(), mOnFailureCallback_110.Cancel());
     }
 
-    void OnFailureResponse_113(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_110(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_113(uint64_t epochUs)
+    void OnSuccessResponse_110(uint64_t epochUs)
     {
         VerifyOrReturn(CheckValue<uint64_t>("epochUs", epochUs, 0ULL));
         NextTest();
     }
 
-    CHIP_ERROR TestReadAttributeEpochSDefaultValue_114()
+    CHIP_ERROR TestReadAttributeEpochSDefaultValue_111()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochS(mOnSuccessCallback_114.Cancel(), mOnFailureCallback_114.Cancel());
+        return cluster.ReadAttributeEpochS(mOnSuccessCallback_111.Cancel(), mOnFailureCallback_111.Cancel());
     }
 
-    void OnFailureResponse_114(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_111(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_114(uint32_t epochS)
+    void OnSuccessResponse_111(uint32_t epochS)
     {
         VerifyOrReturn(CheckValue<uint32_t>("epochS", epochS, 0UL));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeEpochSMaxValue_115()
+    CHIP_ERROR TestWriteAttributeEpochSMaxValue_112()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25693,30 +25586,30 @@ class TestCluster : public TestCommand
         epochSArgument = 4294967295UL;
 
         return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::EpochS::TypeInfo>(
-            epochSArgument, this, OnSuccessCallback_115, OnFailureCallback_115);
+            epochSArgument, this, OnSuccessCallback_112, OnFailureCallback_112);
     }
 
-    void OnFailureResponse_115(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_112(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_115() { NextTest(); }
+    void OnSuccessResponse_112() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeEpochSMaxValue_116()
+    CHIP_ERROR TestReadAttributeEpochSMaxValue_113()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochS(mOnSuccessCallback_116.Cancel(), mOnFailureCallback_116.Cancel());
+        return cluster.ReadAttributeEpochS(mOnSuccessCallback_113.Cancel(), mOnFailureCallback_113.Cancel());
     }
 
-    void OnFailureResponse_116(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_113(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_116(uint32_t epochS)
+    void OnSuccessResponse_113(uint32_t epochS)
     {
         VerifyOrReturn(CheckValue<uint32_t>("epochS", epochS, 4294967295UL));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeEpochSMinValue_117()
+    CHIP_ERROR TestWriteAttributeEpochSMinValue_114()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25725,49 +25618,49 @@ class TestCluster : public TestCommand
         epochSArgument = 0UL;
 
         return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::EpochS::TypeInfo>(
-            epochSArgument, this, OnSuccessCallback_117, OnFailureCallback_117);
+            epochSArgument, this, OnSuccessCallback_114, OnFailureCallback_114);
     }
 
-    void OnFailureResponse_117(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_114(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_117() { NextTest(); }
+    void OnSuccessResponse_114() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeEpochSMinValue_118()
+    CHIP_ERROR TestReadAttributeEpochSMinValue_115()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochS(mOnSuccessCallback_118.Cancel(), mOnFailureCallback_118.Cancel());
+        return cluster.ReadAttributeEpochS(mOnSuccessCallback_115.Cancel(), mOnFailureCallback_115.Cancel());
     }
 
-    void OnFailureResponse_118(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_115(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_118(uint32_t epochS)
+    void OnSuccessResponse_115(uint32_t epochS)
     {
         VerifyOrReturn(CheckValue<uint32_t>("epochS", epochS, 0UL));
         NextTest();
     }
 
-    CHIP_ERROR TestReadAttributeUnsupported_119()
+    CHIP_ERROR TestReadAttributeUnsupported_116()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeUnsupported(mOnSuccessCallback_119.Cancel(), mOnFailureCallback_119.Cancel());
+        return cluster.ReadAttributeUnsupported(mOnSuccessCallback_116.Cancel(), mOnFailureCallback_116.Cancel());
     }
 
-    void OnFailureResponse_119(uint8_t status)
+    void OnFailureResponse_116(uint8_t status)
     {
         (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) ? NextTest() : ThrowFailureResponse();
     }
 
-    void OnSuccessResponse_119(bool unsupported)
+    void OnSuccessResponse_116(bool unsupported)
     {
         VerifyOrReturn(CheckValue<bool>("unsupported", unsupported, 0));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteattributeUnsupported_120()
+    CHIP_ERROR TestWriteattributeUnsupported_117()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25776,17 +25669,17 @@ class TestCluster : public TestCommand
         unsupportedArgument = 0;
 
         return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::Unsupported::TypeInfo>(
-            unsupportedArgument, this, OnSuccessCallback_120, OnFailureCallback_120);
+            unsupportedArgument, this, OnSuccessCallback_117, OnFailureCallback_117);
     }
 
-    void OnFailureResponse_120(uint8_t status)
+    void OnFailureResponse_117(uint8_t status)
     {
         (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) ? NextTest() : ThrowFailureResponse();
     }
 
-    void OnSuccessResponse_120() { NextTest(); }
+    void OnSuccessResponse_117() { NextTest(); }
 
-    CHIP_ERROR TestSendTestCommandToUnsupportedEndpoint_121()
+    CHIP_ERROR TestSendTestCommandToUnsupportedEndpoint_118()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 200);
@@ -25797,36 +25690,36 @@ class TestCluster : public TestCommand
         chip::app::Clusters::TestCluster::Commands::Test::Type request;
 
         auto success = [](void * context, const responseType & data) {
-            (static_cast<TestCluster *>(context))->OnSuccessResponse_121();
+            (static_cast<TestCluster *>(context))->OnSuccessResponse_118();
         };
 
         auto failure = [](void * context, EmberAfStatus status) {
-            (static_cast<TestCluster *>(context))->OnFailureResponse_121(status);
+            (static_cast<TestCluster *>(context))->OnFailureResponse_118(status);
         };
         return cluster.InvokeCommand<requestType, responseType>(request, this, success, failure);
     }
 
-    void OnFailureResponse_121(uint8_t status) { NextTest(); }
+    void OnFailureResponse_118(uint8_t status) { NextTest(); }
 
-    void OnSuccessResponse_121() { ThrowSuccessResponse(); }
+    void OnSuccessResponse_118() { ThrowSuccessResponse(); }
 
-    CHIP_ERROR TestReadAttributeVendorIdDefaultValue_122()
+    CHIP_ERROR TestReadAttributeVendorIdDefaultValue_119()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeVendorId(mOnSuccessCallback_122.Cancel(), mOnFailureCallback_122.Cancel());
+        return cluster.ReadAttributeVendorId(mOnSuccessCallback_119.Cancel(), mOnFailureCallback_119.Cancel());
     }
 
-    void OnFailureResponse_122(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_119(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_122(chip::VendorId vendorId)
+    void OnSuccessResponse_119(chip::VendorId vendorId)
     {
         VerifyOrReturn(CheckValue<chip::VendorId>("vendorId", vendorId, 0U));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeVendorId_123()
+    CHIP_ERROR TestWriteAttributeVendorId_120()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25835,30 +25728,30 @@ class TestCluster : public TestCommand
         vendorIdArgument = static_cast<chip::VendorId>(17);
 
         return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::VendorId::TypeInfo>(
-            vendorIdArgument, this, OnSuccessCallback_123, OnFailureCallback_123);
+            vendorIdArgument, this, OnSuccessCallback_120, OnFailureCallback_120);
     }
 
-    void OnFailureResponse_123(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_120(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_123() { NextTest(); }
+    void OnSuccessResponse_120() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeVendorId_124()
+    CHIP_ERROR TestReadAttributeVendorId_121()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeVendorId(mOnSuccessCallback_124.Cancel(), mOnFailureCallback_124.Cancel());
+        return cluster.ReadAttributeVendorId(mOnSuccessCallback_121.Cancel(), mOnFailureCallback_121.Cancel());
     }
 
-    void OnFailureResponse_124(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_121(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_124(chip::VendorId vendorId)
+    void OnSuccessResponse_121(chip::VendorId vendorId)
     {
         VerifyOrReturn(CheckValue<chip::VendorId>("vendorId", vendorId, 17U));
         NextTest();
     }
 
-    CHIP_ERROR TestRestoreAttributeVendorId_125()
+    CHIP_ERROR TestRestoreAttributeVendorId_122()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25867,14 +25760,14 @@ class TestCluster : public TestCommand
         vendorIdArgument = static_cast<chip::VendorId>(0);
 
         return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::VendorId::TypeInfo>(
-            vendorIdArgument, this, OnSuccessCallback_125, OnFailureCallback_125);
+            vendorIdArgument, this, OnSuccessCallback_122, OnFailureCallback_122);
     }
 
-    void OnFailureResponse_125(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_122(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_125() { NextTest(); }
+    void OnSuccessResponse_122() { NextTest(); }
 
-    CHIP_ERROR TestSendACommandWithAVendorIdAndEnum_126()
+    CHIP_ERROR TestSendACommandWithAVendorIdAndEnum_123()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25887,18 +25780,18 @@ class TestCluster : public TestCommand
         request.arg2 = static_cast<chip::app::Clusters::TestCluster::SimpleEnum>(101);
 
         auto success = [](void * context, const responseType & data) {
-            (static_cast<TestCluster *>(context))->OnSuccessResponse_126(data.arg1, data.arg2);
+            (static_cast<TestCluster *>(context))->OnSuccessResponse_123(data.arg1, data.arg2);
         };
 
         auto failure = [](void * context, EmberAfStatus status) {
-            (static_cast<TestCluster *>(context))->OnFailureResponse_126(status);
+            (static_cast<TestCluster *>(context))->OnFailureResponse_123(status);
         };
         return cluster.InvokeCommand<requestType, responseType>(request, this, success, failure);
     }
 
-    void OnFailureResponse_126(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_123(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_126(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2)
+    void OnSuccessResponse_123(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2)
     {
         VerifyOrReturn(CheckValue<chip::VendorId>("arg1", arg1, 20003U));
 
@@ -25974,16 +25867,41 @@ class TestClusterComplexTypes : public TestCommand
             err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_7();
             break;
         case 8:
-            ChipLogProgress(chipTool, " ***** Test Step 8 : Send Test Command with optional arg set.\n");
-            err = TestSendTestCommandWithOptionalArgSet_8();
+            ChipLogProgress(chipTool,
+                            " ***** Test Step 8 : Write attribute LIST With List of INT8U and none of them is set to 0\n");
+            err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_8();
             break;
         case 9:
-            ChipLogProgress(chipTool, " ***** Test Step 9 : Send Test Command without its optional arg.\n");
-            err = TestSendTestCommandWithoutItsOptionalArg_9();
+            ChipLogProgress(chipTool, " ***** Test Step 9 : Read attribute LIST With List of INT8U\n");
+            err = TestReadAttributeListWithListOfInt8u_9();
             break;
         case 10:
-            ChipLogProgress(chipTool, " ***** Test Step 10 : Send Test Command with optional arg set to null.\n");
-            err = TestSendTestCommandWithOptionalArgSetToNull_10();
+            ChipLogProgress(chipTool, " ***** Test Step 10 : Write attribute LIST With List of OCTET_STRING\n");
+            err = TestWriteAttributeListWithListOfOctetString_10();
+            break;
+        case 11:
+            ChipLogProgress(chipTool, " ***** Test Step 11 : Read attribute LIST With List of OCTET_STRING\n");
+            err = TestReadAttributeListWithListOfOctetString_11();
+            break;
+        case 12:
+            ChipLogProgress(chipTool, " ***** Test Step 12 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n");
+            err = TestWriteAttributeListWithListOfListStructOctetString_12();
+            break;
+        case 13:
+            ChipLogProgress(chipTool, " ***** Test Step 13 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n");
+            err = TestReadAttributeListWithListOfListStructOctetString_13();
+            break;
+        case 14:
+            ChipLogProgress(chipTool, " ***** Test Step 14 : Send Test Command with optional arg set.\n");
+            err = TestSendTestCommandWithOptionalArgSet_14();
+            break;
+        case 15:
+            ChipLogProgress(chipTool, " ***** Test Step 15 : Send Test Command without its optional arg.\n");
+            err = TestSendTestCommandWithoutItsOptionalArg_15();
+            break;
+        case 16:
+            ChipLogProgress(chipTool, " ***** Test Step 16 : Send Test Command with optional arg set to null.\n");
+            err = TestSendTestCommandWithOptionalArgSetToNull_16();
             break;
         }
 
@@ -25996,7 +25914,74 @@ class TestClusterComplexTypes : public TestCommand
 
 private:
     std::atomic_uint16_t mTestIndex;
-    const uint16_t mTestCount = 11;
+    const uint16_t mTestCount = 17;
+
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_9{ OnFailureCallback_9, this };
+    chip::Callback::Callback<void (*)(void * context, const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)>
+        mOnSuccessCallback_9{ OnSuccessCallback_9, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_11{ OnFailureCallback_11, this };
+    chip::Callback::Callback<void (*)(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)>
+        mOnSuccessCallback_11{ OnSuccessCallback_11, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_13{ OnFailureCallback_13, this };
+    chip::Callback::Callback<void (*)(
+        void * context,
+        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
+            listStructOctetString)>
+        mOnSuccessCallback_13{ OnSuccessCallback_13, this };
+
+    static void OnFailureCallback_8(void * context, EmberAfStatus status)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_8(chip::to_underlying(status));
+    }
+
+    static void OnSuccessCallback_8(void * context) { (static_cast<TestClusterComplexTypes *>(context))->OnSuccessResponse_8(); }
+
+    static void OnFailureCallback_9(void * context, uint8_t status)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_9(status);
+    }
+
+    static void OnSuccessCallback_9(void * context, const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnSuccessResponse_9(listInt8u);
+    }
+
+    static void OnFailureCallback_10(void * context, EmberAfStatus status)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_10(chip::to_underlying(status));
+    }
+
+    static void OnSuccessCallback_10(void * context) { (static_cast<TestClusterComplexTypes *>(context))->OnSuccessResponse_10(); }
+
+    static void OnFailureCallback_11(void * context, uint8_t status)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_11(status);
+    }
+
+    static void OnSuccessCallback_11(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnSuccessResponse_11(listOctetString);
+    }
+
+    static void OnFailureCallback_12(void * context, EmberAfStatus status)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_12(chip::to_underlying(status));
+    }
+
+    static void OnSuccessCallback_12(void * context) { (static_cast<TestClusterComplexTypes *>(context))->OnSuccessResponse_12(); }
+
+    static void OnFailureCallback_13(void * context, uint8_t status)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_13(status);
+    }
+
+    static void OnSuccessCallback_13(
+        void * context,
+        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
+            listStructOctetString)
+    {
+        (static_cast<TestClusterComplexTypes *>(context))->OnSuccessResponse_13(listStructOctetString);
+    }
 
     //
     // Tests methods
@@ -26315,7 +26300,133 @@ class TestClusterComplexTypes : public TestCommand
         NextTest();
     }
 
-    CHIP_ERROR TestSendTestCommandWithOptionalArgSet_8()
+    CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_8()
+    {
+        chip::Controller::TestClusterClusterTest cluster;
+        cluster.Associate(mDevice, 1);
+
+        chip::app::DataModel::List<const uint8_t> listInt8uArgument;
+
+        uint8_t listInt8uList[4];
+        listInt8uList[0]  = 1;
+        listInt8uList[1]  = 2;
+        listInt8uList[2]  = 3;
+        listInt8uList[3]  = 4;
+        listInt8uArgument = listInt8uList;
+
+        return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::ListInt8u::TypeInfo>(
+            listInt8uArgument, this, OnSuccessCallback_8, OnFailureCallback_8);
+    }
+
+    void OnFailureResponse_8(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_8() { NextTest(); }
+
+    CHIP_ERROR TestReadAttributeListWithListOfInt8u_9()
+    {
+        chip::Controller::TestClusterClusterTest cluster;
+        cluster.Associate(mDevice, 1);
+
+        return cluster.ReadAttributeListInt8u(mOnSuccessCallback_9.Cancel(), mOnFailureCallback_9.Cancel());
+    }
+
+    void OnFailureResponse_9(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_9(const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)
+    {
+        VerifyOrReturn(CheckValueAsListLength("listInt8u", listInt8u, 4));
+        NextTest();
+    }
+
+    CHIP_ERROR TestWriteAttributeListWithListOfOctetString_10()
+    {
+        chip::Controller::TestClusterClusterTest cluster;
+        cluster.Associate(mDevice, 1);
+
+        chip::app::DataModel::List<const chip::ByteSpan> listOctetStringArgument;
+
+        chip::ByteSpan listOctetStringList[4];
+        listOctetStringList[0]  = chip::ByteSpan(chip::Uint8::from_const_char("Test0"), strlen("Test0"));
+        listOctetStringList[1]  = chip::ByteSpan(chip::Uint8::from_const_char("Test1"), strlen("Test1"));
+        listOctetStringList[2]  = chip::ByteSpan(chip::Uint8::from_const_char("Test2"), strlen("Test2"));
+        listOctetStringList[3]  = chip::ByteSpan(chip::Uint8::from_const_char("Test3"), strlen("Test3"));
+        listOctetStringArgument = listOctetStringList;
+
+        return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::ListOctetString::TypeInfo>(
+            listOctetStringArgument, this, OnSuccessCallback_10, OnFailureCallback_10);
+    }
+
+    void OnFailureResponse_10(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_10() { NextTest(); }
+
+    CHIP_ERROR TestReadAttributeListWithListOfOctetString_11()
+    {
+        chip::Controller::TestClusterClusterTest cluster;
+        cluster.Associate(mDevice, 1);
+
+        return cluster.ReadAttributeListOctetString(mOnSuccessCallback_11.Cancel(), mOnFailureCallback_11.Cancel());
+    }
+
+    void OnFailureResponse_11(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_11(const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)
+    {
+        VerifyOrReturn(CheckValueAsListLength("listOctetString", listOctetString, 4));
+        NextTest();
+    }
+
+    CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_12()
+    {
+        chip::Controller::TestClusterClusterTest cluster;
+        cluster.Associate(mDevice, 1);
+
+        chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::TestListStructOctet::Type>
+            listStructOctetStringArgument;
+
+        chip::app::Clusters::TestCluster::Structs::TestListStructOctet::Type listStructOctetStringList[4];
+
+        listStructOctetStringList[0].fabricIndex     = 0ULL;
+        listStructOctetStringList[0].operationalCert = chip::ByteSpan(chip::Uint8::from_const_char("Test0"), strlen("Test0"));
+
+        listStructOctetStringList[1].fabricIndex     = 1ULL;
+        listStructOctetStringList[1].operationalCert = chip::ByteSpan(chip::Uint8::from_const_char("Test1"), strlen("Test1"));
+
+        listStructOctetStringList[2].fabricIndex     = 2ULL;
+        listStructOctetStringList[2].operationalCert = chip::ByteSpan(chip::Uint8::from_const_char("Test2"), strlen("Test2"));
+
+        listStructOctetStringList[3].fabricIndex     = 3ULL;
+        listStructOctetStringList[3].operationalCert = chip::ByteSpan(chip::Uint8::from_const_char("Test3"), strlen("Test3"));
+
+        listStructOctetStringArgument = listStructOctetStringList;
+
+        return cluster.WriteAttribute<chip::app::Clusters::TestCluster::Attributes::ListStructOctetString::TypeInfo>(
+            listStructOctetStringArgument, this, OnSuccessCallback_12, OnFailureCallback_12);
+    }
+
+    void OnFailureResponse_12(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_12() { NextTest(); }
+
+    CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_13()
+    {
+        chip::Controller::TestClusterClusterTest cluster;
+        cluster.Associate(mDevice, 1);
+
+        return cluster.ReadAttributeListStructOctetString(mOnSuccessCallback_13.Cancel(), mOnFailureCallback_13.Cancel());
+    }
+
+    void OnFailureResponse_13(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_13(
+        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
+            listStructOctetString)
+    {
+        VerifyOrReturn(CheckValueAsListLength("listStructOctetString", listStructOctetString, 4));
+        NextTest();
+    }
+
+    CHIP_ERROR TestSendTestCommandWithOptionalArgSet_14()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -26328,19 +26439,19 @@ class TestClusterComplexTypes : public TestCommand
 
         auto success = [](void * context, const responseType & data) {
             (static_cast<TestClusterComplexTypes *>(context))
-                ->OnSuccessResponse_8(data.wasPresent, data.wasNull, data.value, data.originalValue);
+                ->OnSuccessResponse_14(data.wasPresent, data.wasNull, data.value, data.originalValue);
         };
 
         auto failure = [](void * context, EmberAfStatus status) {
-            (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_8(status);
+            (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_14(status);
         };
         return cluster.InvokeCommand<requestType, responseType>(request, this, success, failure);
     }
 
-    void OnFailureResponse_8(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_14(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_8(bool wasPresent, const chip::Optional<bool> & wasNull, const chip::Optional<uint8_t> & value,
-                             const chip::Optional<chip::app::DataModel::Nullable<uint8_t>> & originalValue)
+    void OnSuccessResponse_14(bool wasPresent, const chip::Optional<bool> & wasNull, const chip::Optional<uint8_t> & value,
+                              const chip::Optional<chip::app::DataModel::Nullable<uint8_t>> & originalValue)
     {
         VerifyOrReturn(CheckValue<bool>("wasPresent", wasPresent, true));
 
@@ -26356,7 +26467,7 @@ class TestClusterComplexTypes : public TestCommand
         NextTest();
     }
 
-    CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_9()
+    CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_15()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -26368,26 +26479,26 @@ class TestClusterComplexTypes : public TestCommand
 
         auto success = [](void * context, const responseType & data) {
             (static_cast<TestClusterComplexTypes *>(context))
-                ->OnSuccessResponse_9(data.wasPresent, data.wasNull, data.value, data.originalValue);
+                ->OnSuccessResponse_15(data.wasPresent, data.wasNull, data.value, data.originalValue);
         };
 
         auto failure = [](void * context, EmberAfStatus status) {
-            (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_9(status);
+            (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_15(status);
         };
         return cluster.InvokeCommand<requestType, responseType>(request, this, success, failure);
     }
 
-    void OnFailureResponse_9(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_15(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_9(bool wasPresent, const chip::Optional<bool> & wasNull, const chip::Optional<uint8_t> & value,
-                             const chip::Optional<chip::app::DataModel::Nullable<uint8_t>> & originalValue)
+    void OnSuccessResponse_15(bool wasPresent, const chip::Optional<bool> & wasNull, const chip::Optional<uint8_t> & value,
+                              const chip::Optional<chip::app::DataModel::Nullable<uint8_t>> & originalValue)
     {
         VerifyOrReturn(CheckValue<bool>("wasPresent", wasPresent, false));
 
         NextTest();
     }
 
-    CHIP_ERROR TestSendTestCommandWithOptionalArgSetToNull_10()
+    CHIP_ERROR TestSendTestCommandWithOptionalArgSetToNull_16()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -26400,18 +26511,18 @@ class TestClusterComplexTypes : public TestCommand
 
         auto success = [](void * context, const responseType & data) {
             (static_cast<TestClusterComplexTypes *>(context))
-                ->OnSuccessResponse_10(data.wasPresent, data.wasNull, data.value, data.originalValue);
+                ->OnSuccessResponse_16(data.wasPresent, data.wasNull, data.value, data.originalValue);
         };
 
         auto failure = [](void * context, EmberAfStatus status) {
-            (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_10(status);
+            (static_cast<TestClusterComplexTypes *>(context))->OnFailureResponse_16(status);
         };
         return cluster.InvokeCommand<requestType, responseType>(request, this, success, failure);
     }
 
-    void OnFailureResponse_10(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_16(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_10(bool wasPresent, const chip::Optional<bool> & wasNull, const chip::Optional<uint8_t> & value,
+    void OnSuccessResponse_16(bool wasPresent, const chip::Optional<bool> & wasNull, const chip::Optional<uint8_t> & value,
                               const chip::Optional<chip::app::DataModel::Nullable<uint8_t>> & originalValue)
     {
         VerifyOrReturn(CheckValue<bool>("wasPresent", wasPresent, true));
diff --git a/zzz_generated/thermostat/zap-generated/endpoint_config.h b/zzz_generated/thermostat/zap-generated/endpoint_config.h
index e4c34443529e71..da50ccafa3322f 100644
--- a/zzz_generated/thermostat/zap-generated/endpoint_config.h
+++ b/zzz_generated/thermostat/zap-generated/endpoint_config.h
@@ -824,7 +824,7 @@
             /* Endpoint: 1, Cluster: Thermostat (server), little-endian */                                                         \
                                                                                                                                    \
             /* 2526 - FeatureMap, */                                                                                               \
-            0x0B, 0x00, 0x00, 0x00,                                                                                                \
+            0x00, 0x00, 0x00, 0x0B,                                                                                                \
     }
 
 #endif // BIGENDIAN_CPU
diff --git a/zzz_generated/tv-app/zap-generated/endpoint_config.h b/zzz_generated/tv-app/zap-generated/endpoint_config.h
index 660417520396e9..6dabcea352081b 100644
--- a/zzz_generated/tv-app/zap-generated/endpoint_config.h
+++ b/zzz_generated/tv-app/zap-generated/endpoint_config.h
@@ -1164,7 +1164,7 @@
             /* Endpoint: 3, Cluster: Media Playback (server), little-endian */                                                     \
                                                                                                                                    \
             /* 4167 - start time, */                                                                                               \
-            0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,                                                                        \
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,                                                                        \
                                                                                                                                    \
             /* 4175 - duration, */                                                                                                 \
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,                                                                        \
diff --git a/zzz_generated/tv-casting-app/zap-generated/endpoint_config.h b/zzz_generated/tv-casting-app/zap-generated/endpoint_config.h
index 53be74d0454a54..6a8f6d3a8fa039 100644
--- a/zzz_generated/tv-casting-app/zap-generated/endpoint_config.h
+++ b/zzz_generated/tv-casting-app/zap-generated/endpoint_config.h
@@ -1242,7 +1242,7 @@
             /* Endpoint: 1, Cluster: Thermostat (server), little-endian */                                                         \
                                                                                                                                    \
             /* 3406 - FeatureMap, */                                                                                               \
-            0x0B, 0x00, 0x00, 0x00,                                                                                                \
+            0x00, 0x00, 0x00, 0x0B,                                                                                                \
                                                                                                                                    \
             /* Endpoint: 1, Cluster: Color Control (server), little-endian */                                                      \
                                                                                                                                    \
diff --git a/zzz_generated/window-app/zap-generated/endpoint_config.h b/zzz_generated/window-app/zap-generated/endpoint_config.h
index f1c01393f0180e..9afe49c8ecaf52 100644
--- a/zzz_generated/window-app/zap-generated/endpoint_config.h
+++ b/zzz_generated/window-app/zap-generated/endpoint_config.h
@@ -631,12 +631,12 @@
             /* Endpoint: 1, Cluster: Window Covering (server), little-endian */                                                    \
                                                                                                                                    \
             /* 1377 - FeatureMap, */                                                                                               \
-            0x01, 0x00, 0x00, 0x00,                                                                                                \
+            0x00, 0x00, 0x00, 0x01,                                                                                                \
                                                                                                                                    \
             /* Endpoint: 2, Cluster: Window Covering (server), little-endian */                                                    \
                                                                                                                                    \
             /* 1381 - FeatureMap, */                                                                                               \
-            0x01, 0x00, 0x00, 0x00,                                                                                                \
+            0x00, 0x00, 0x00, 0x01,                                                                                                \
     }
 
 #endif // BIGENDIAN_CPU