diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
index dd1f9115475224..3f0cde4b5dc8fe 100644
--- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
+++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
@@ -13859,7 +13859,28 @@ - (void)testSendClusterTestCluster_000105_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000106_ReadAttribute
+- (void)testSendClusterTestCluster_000106_WriteAttribute
+{
+    XCTestExpectation * expectation = [self expectationWithDescription:@"Write 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);
+
+    uint8_t listInt8uArgument = 1, 2, 3, 4;
+    [cluster writeAttributeListInt8uWithValue:listInt8uArgument
+                              responseHandler:^(NSError * err, NSDictionary * values) {
+                                  NSLog(@"Write attribute LIST Error: %@", err);
+
+                                  XCTAssertEqual(err.code, 0);
+
+                                  [expectation fulfill];
+                              }];
+
+    [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+- (void)testSendClusterTestCluster_000107_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST"];
 
@@ -13880,7 +13901,29 @@ - (void)testSendClusterTestCluster_000106_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000107_ReadAttribute
+- (void)testSendClusterTestCluster_000108_WriteAttribute
+{
+    XCTestExpectation * expectation = [self expectationWithDescription:@"Write 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);
+
+    NSString * listOctetStringArgumentString = @"Test0,Test1,Test2,Test3";
+    NSData * listOctetStringArgument = [listOctetStringArgumentString dataUsingEncoding:NSUTF8StringEncoding];
+    [cluster writeAttributeListOctetStringWithValue:listOctetStringArgument
+                                    responseHandler:^(NSError * err, NSDictionary * values) {
+                                        NSLog(@"Write attribute LIST_OCTET_STRING Error: %@", err);
+
+                                        XCTAssertEqual(err.code, 0);
+
+                                        [expectation fulfill];
+                                    }];
+
+    [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+- (void)testSendClusterTestCluster_000109_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST_OCTET_STRING"];
 
@@ -13901,7 +13944,28 @@ - (void)testSendClusterTestCluster_000107_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000108_ReadAttribute
+- (void)testSendClusterTestCluster_000110_WriteAttribute
+{
+    XCTestExpectation * expectation = [self expectationWithDescription:@"Write 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);
+
+    _TestListStructOctet listStructOctetStringArgument = [object Object], [object Object], [object Object], [object Object];
+    [cluster writeAttributeListStructOctetStringWithValue:listStructOctetStringArgument
+                                          responseHandler:^(NSError * err, NSDictionary * values) {
+                                              NSLog(@"Write attribute LIST_STRUCT_OCTET_STRING Error: %@", err);
+
+                                              XCTAssertEqual(err.code, 0);
+
+                                              [expectation fulfill];
+                                          }];
+
+    [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+- (void)testSendClusterTestCluster_000111_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST_STRUCT_OCTET_STRING"];
 
@@ -13922,7 +13986,7 @@ - (void)testSendClusterTestCluster_000108_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000109_ReadAttribute
+- (void)testSendClusterTestCluster_000112_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Default Value"];
 
@@ -13943,7 +14007,7 @@ - (void)testSendClusterTestCluster_000109_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000110_WriteAttribute
+- (void)testSendClusterTestCluster_000113_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Max Value"];
 
@@ -13964,7 +14028,7 @@ - (void)testSendClusterTestCluster_000110_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000111_ReadAttribute
+- (void)testSendClusterTestCluster_000114_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Max Value"];
 
@@ -13985,7 +14049,7 @@ - (void)testSendClusterTestCluster_000111_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000112_WriteAttribute
+- (void)testSendClusterTestCluster_000115_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Min Value"];
 
@@ -14006,7 +14070,7 @@ - (void)testSendClusterTestCluster_000112_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000113_ReadAttribute
+- (void)testSendClusterTestCluster_000116_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Min Value"];
 
@@ -14027,7 +14091,7 @@ - (void)testSendClusterTestCluster_000113_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000114_ReadAttribute
+- (void)testSendClusterTestCluster_000117_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Default Value"];
 
@@ -14048,7 +14112,7 @@ - (void)testSendClusterTestCluster_000114_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000115_WriteAttribute
+- (void)testSendClusterTestCluster_000118_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Max Value"];
 
@@ -14069,7 +14133,7 @@ - (void)testSendClusterTestCluster_000115_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000116_ReadAttribute
+- (void)testSendClusterTestCluster_000119_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Max Value"];
 
@@ -14090,7 +14154,7 @@ - (void)testSendClusterTestCluster_000116_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000117_WriteAttribute
+- (void)testSendClusterTestCluster_000120_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Min Value"];
 
@@ -14111,7 +14175,7 @@ - (void)testSendClusterTestCluster_000117_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000118_ReadAttribute
+- (void)testSendClusterTestCluster_000121_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Min Value"];
 
@@ -14132,7 +14196,7 @@ - (void)testSendClusterTestCluster_000118_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000119_ReadAttribute
+- (void)testSendClusterTestCluster_000122_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute UNSUPPORTED"];
 
@@ -14158,7 +14222,7 @@ - (void)testSendClusterTestCluster_000119_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000120_WriteAttribute
+- (void)testSendClusterTestCluster_000123_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Writeattribute UNSUPPORTED"];
 
@@ -14184,7 +14248,7 @@ - (void)testSendClusterTestCluster_000120_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000121_Test
+- (void)testSendClusterTestCluster_000124_Test
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command to unsupported endpoint"];
 
@@ -14202,7 +14266,7 @@ - (void)testSendClusterTestCluster_000121_Test
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000122_ReadAttribute
+- (void)testSendClusterTestCluster_000125_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id Default Value"];
 
@@ -14223,7 +14287,7 @@ - (void)testSendClusterTestCluster_000122_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000123_WriteAttribute
+- (void)testSendClusterTestCluster_000126_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute vendor_id"];
 
@@ -14244,7 +14308,7 @@ - (void)testSendClusterTestCluster_000123_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000124_ReadAttribute
+- (void)testSendClusterTestCluster_000127_ReadAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id"];
 
@@ -14265,7 +14329,7 @@ - (void)testSendClusterTestCluster_000124_ReadAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000125_WriteAttribute
+- (void)testSendClusterTestCluster_000128_WriteAttribute
 {
     XCTestExpectation * expectation = [self expectationWithDescription:@"Restore attribute vendor_id"];
 
@@ -14286,7 +14350,7 @@ - (void)testSendClusterTestCluster_000125_WriteAttribute
 
     [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
 }
-- (void)testSendClusterTestCluster_000126_TestEnumsRequest
+- (void)testSendClusterTestCluster_000129_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 eee8515be32114..2ef395c2251870 100644
--- a/zzz_generated/chip-tool/zap-generated/test/Commands.h
+++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h
@@ -22149,88 +22149,100 @@ 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 : Write attribute LIST\n");
+            err = TestWriteAttributeList_106();
             break;
         case 107:
-            ChipLogProgress(chipTool, " ***** Test Step 107 : Read attribute LIST_OCTET_STRING\n");
-            err = TestReadAttributeListOctetString_107();
+            ChipLogProgress(chipTool, " ***** Test Step 107 : Read attribute LIST\n");
+            err = TestReadAttributeList_107();
             break;
         case 108:
-            ChipLogProgress(chipTool, " ***** Test Step 108 : Read attribute LIST_STRUCT_OCTET_STRING\n");
-            err = TestReadAttributeListStructOctetString_108();
+            ChipLogProgress(chipTool, " ***** Test Step 108 : Write attribute LIST_OCTET_STRING\n");
+            err = TestWriteAttributeListOctetString_108();
             break;
         case 109:
-            ChipLogProgress(chipTool, " ***** Test Step 109 : Read attribute EPOCH_US Default Value\n");
-            err = TestReadAttributeEpochUsDefaultValue_109();
+            ChipLogProgress(chipTool, " ***** Test Step 109 : Read attribute LIST_OCTET_STRING\n");
+            err = TestReadAttributeListOctetString_109();
             break;
         case 110:
-            ChipLogProgress(chipTool, " ***** Test Step 110 : Write attribute EPOCH_US Max Value\n");
-            err = TestWriteAttributeEpochUsMaxValue_110();
+            ChipLogProgress(chipTool, " ***** Test Step 110 : Write attribute LIST_STRUCT_OCTET_STRING\n");
+            err = TestWriteAttributeListStructOctetString_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 LIST_STRUCT_OCTET_STRING\n");
+            err = TestReadAttributeListStructOctetString_111();
             break;
         case 112:
-            ChipLogProgress(chipTool, " ***** Test Step 112 : Write attribute EPOCH_US Min Value\n");
-            err = TestWriteAttributeEpochUsMinValue_112();
+            ChipLogProgress(chipTool, " ***** Test Step 112 : Read attribute EPOCH_US Default Value\n");
+            err = TestReadAttributeEpochUsDefaultValue_112();
             break;
         case 113:
-            ChipLogProgress(chipTool, " ***** Test Step 113 : Read attribute EPOCH_US Min Value\n");
-            err = TestReadAttributeEpochUsMinValue_113();
+            ChipLogProgress(chipTool, " ***** Test Step 113 : Write attribute EPOCH_US Max Value\n");
+            err = TestWriteAttributeEpochUsMaxValue_113();
             break;
         case 114:
-            ChipLogProgress(chipTool, " ***** Test Step 114 : Read attribute EPOCH_S Default Value\n");
-            err = TestReadAttributeEpochSDefaultValue_114();
+            ChipLogProgress(chipTool, " ***** Test Step 114 : Read attribute EPOCH_US Max Value\n");
+            err = TestReadAttributeEpochUsMaxValue_114();
             break;
         case 115:
-            ChipLogProgress(chipTool, " ***** Test Step 115 : Write attribute EPOCH_S Max Value\n");
-            err = TestWriteAttributeEpochSMaxValue_115();
+            ChipLogProgress(chipTool, " ***** Test Step 115 : Write attribute EPOCH_US Min Value\n");
+            err = TestWriteAttributeEpochUsMinValue_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 EPOCH_US Min Value\n");
+            err = TestReadAttributeEpochUsMinValue_116();
             break;
         case 117:
-            ChipLogProgress(chipTool, " ***** Test Step 117 : Write attribute EPOCH_S Min Value\n");
-            err = TestWriteAttributeEpochSMinValue_117();
+            ChipLogProgress(chipTool, " ***** Test Step 117 : Read attribute EPOCH_S Default Value\n");
+            err = TestReadAttributeEpochSDefaultValue_117();
             break;
         case 118:
-            ChipLogProgress(chipTool, " ***** Test Step 118 : Read attribute EPOCH_S Min Value\n");
-            err = TestReadAttributeEpochSMinValue_118();
+            ChipLogProgress(chipTool, " ***** Test Step 118 : Write attribute EPOCH_S Max Value\n");
+            err = TestWriteAttributeEpochSMaxValue_118();
             break;
         case 119:
-            ChipLogProgress(chipTool, " ***** Test Step 119 : Read attribute UNSUPPORTED\n");
-            err = TestReadAttributeUnsupported_119();
+            ChipLogProgress(chipTool, " ***** Test Step 119 : Read attribute EPOCH_S Max Value\n");
+            err = TestReadAttributeEpochSMaxValue_119();
             break;
         case 120:
-            ChipLogProgress(chipTool, " ***** Test Step 120 : Writeattribute UNSUPPORTED\n");
-            err = TestWriteattributeUnsupported_120();
+            ChipLogProgress(chipTool, " ***** Test Step 120 : Write attribute EPOCH_S Min Value\n");
+            err = TestWriteAttributeEpochSMinValue_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 EPOCH_S Min Value\n");
+            err = TestReadAttributeEpochSMinValue_121();
             break;
         case 122:
-            ChipLogProgress(chipTool, " ***** Test Step 122 : Read attribute vendor_id Default Value\n");
-            err = TestReadAttributeVendorIdDefaultValue_122();
+            ChipLogProgress(chipTool, " ***** Test Step 122 : Read attribute UNSUPPORTED\n");
+            err = TestReadAttributeUnsupported_122();
             break;
         case 123:
-            ChipLogProgress(chipTool, " ***** Test Step 123 : Write attribute vendor_id\n");
-            err = TestWriteAttributeVendorId_123();
+            ChipLogProgress(chipTool, " ***** Test Step 123 : Writeattribute UNSUPPORTED\n");
+            err = TestWriteattributeUnsupported_123();
             break;
         case 124:
-            ChipLogProgress(chipTool, " ***** Test Step 124 : Read attribute vendor_id\n");
-            err = TestReadAttributeVendorId_124();
+            ChipLogProgress(chipTool, " ***** Test Step 124 : Send Test Command to unsupported endpoint\n");
+            err = TestSendTestCommandToUnsupportedEndpoint_124();
             break;
         case 125:
-            ChipLogProgress(chipTool, " ***** Test Step 125 : Restore attribute vendor_id\n");
-            err = TestRestoreAttributeVendorId_125();
+            ChipLogProgress(chipTool, " ***** Test Step 125 : Read attribute vendor_id Default Value\n");
+            err = TestReadAttributeVendorIdDefaultValue_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 126 : Write attribute vendor_id\n");
+            err = TestWriteAttributeVendorId_126();
+            break;
+        case 127:
+            ChipLogProgress(chipTool, " ***** Test Step 127 : Read attribute vendor_id\n");
+            err = TestReadAttributeVendorId_127();
+            break;
+        case 128:
+            ChipLogProgress(chipTool, " ***** Test Step 128 : Restore attribute vendor_id\n");
+            err = TestRestoreAttributeVendorId_128();
+            break;
+        case 129:
+            ChipLogProgress(chipTool, " ***** Test Step 129 : Send a command with a vendor_id and enum\n");
+            err = TestSendACommandWithAVendorIdAndEnum_129();
             break;
         }
 
@@ -22243,7 +22255,7 @@ class TestCluster : public TestCommand
 
 private:
     std::atomic_uint16_t mTestIndex;
-    const uint16_t mTestCount = 127;
+    const uint16_t mTestCount = 130;
 
     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 };
@@ -22367,37 +22379,37 @@ class TestCluster : public TestCommand
     chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_104{ OnFailureCallback_104, this };
     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)>
+    chip::Callback::Callback<void (*)(void * context, const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)>
         mOnSuccessCallback_107{ OnSuccessCallback_107, this };
-    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_108{ OnFailureCallback_108, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_109{ OnFailureCallback_109, this };
+    chip::Callback::Callback<void (*)(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)>
+        mOnSuccessCallback_109{ OnSuccessCallback_109, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_111{ OnFailureCallback_111, 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, 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, uint8_t status)> mOnFailureCallback_113{ OnFailureCallback_113, this };
-    chip::Callback::Callback<void (*)(void * context, uint64_t epochUs)> mOnSuccessCallback_113{ OnSuccessCallback_113, this };
+        mOnSuccessCallback_111{ OnSuccessCallback_111, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_112{ OnFailureCallback_112, this };
+    chip::Callback::Callback<void (*)(void * context, uint64_t epochUs)> mOnSuccessCallback_112{ OnSuccessCallback_112, 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, uint64_t epochUs)> mOnSuccessCallback_114{ OnSuccessCallback_114, 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, uint64_t epochUs)> mOnSuccessCallback_116{ OnSuccessCallback_116, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_117{ OnFailureCallback_117, this };
+    chip::Callback::Callback<void (*)(void * context, uint32_t epochS)> mOnSuccessCallback_117{ OnSuccessCallback_117, 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, uint32_t epochS)> mOnSuccessCallback_119{ OnSuccessCallback_119, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_121{ OnFailureCallback_121, this };
+    chip::Callback::Callback<void (*)(void * context, uint32_t epochS)> mOnSuccessCallback_121{ OnSuccessCallback_121, 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, bool unsupported)> mOnSuccessCallback_122{ OnSuccessCallback_122, this };
+    chip::Callback::Callback<void (*)(void * context, uint8_t status)> mOnFailureCallback_125{ OnFailureCallback_125, this };
+    chip::Callback::Callback<void (*)(void * context, chip::VendorId vendorId)> mOnSuccessCallback_125{ OnSuccessCallback_125,
                                                                                                         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_127{ OnFailureCallback_127, this };
+    chip::Callback::Callback<void (*)(void * context, chip::VendorId vendorId)> mOnSuccessCallback_127{ OnSuccessCallback_127,
                                                                                                         this };
 
     static void OnFailureCallback_5(void * context, uint8_t status)
@@ -23278,47 +23290,38 @@ class TestCluster : public TestCommand
 
     static void OnSuccessCallback_105(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_105(); }
 
-    static void OnFailureCallback_106(void * context, uint8_t status)
+    static void OnFailureCallback_106(void * context, EmberAfStatus status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_106(status);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_106(chip::to_underlying(status));
     }
 
-    static void OnSuccessCallback_106(void * context, const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)
-    {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_106(listInt8u);
-    }
+    static void OnSuccessCallback_106(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_106(); }
 
     static void OnFailureCallback_107(void * context, uint8_t status)
     {
         (static_cast<TestCluster *>(context))->OnFailureResponse_107(status);
     }
 
-    static void OnSuccessCallback_107(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)
+    static void OnSuccessCallback_107(void * context, const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_107(listOctetString);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_107(listInt8u);
     }
 
-    static void OnFailureCallback_108(void * context, uint8_t status)
+    static void OnFailureCallback_108(void * context, EmberAfStatus status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_108(status);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_108(chip::to_underlying(status));
     }
 
-    static void OnSuccessCallback_108(
-        void * context,
-        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
-            listStructOctetString)
-    {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_108(listStructOctetString);
-    }
+    static void OnSuccessCallback_108(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_108(); }
 
     static void OnFailureCallback_109(void * context, uint8_t status)
     {
         (static_cast<TestCluster *>(context))->OnFailureResponse_109(status);
     }
 
-    static void OnSuccessCallback_109(void * context, uint64_t epochUs)
+    static void OnSuccessCallback_109(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_109(epochUs);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_109(listOctetString);
     }
 
     static void OnFailureCallback_110(void * context, EmberAfStatus status)
@@ -23333,36 +23336,39 @@ class TestCluster : public TestCommand
         (static_cast<TestCluster *>(context))->OnFailureResponse_111(status);
     }
 
-    static void OnSuccessCallback_111(void * context, uint64_t epochUs)
+    static void OnSuccessCallback_111(
+        void * context,
+        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
+            listStructOctetString)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_111(epochUs);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_111(listStructOctetString);
     }
 
-    static void OnFailureCallback_112(void * context, EmberAfStatus status)
+    static void OnFailureCallback_112(void * context, uint8_t status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_112(chip::to_underlying(status));
+        (static_cast<TestCluster *>(context))->OnFailureResponse_112(status);
     }
 
-    static void OnSuccessCallback_112(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_112(); }
-
-    static void OnFailureCallback_113(void * context, uint8_t status)
+    static void OnSuccessCallback_112(void * context, uint64_t epochUs)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_113(status);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_112(epochUs);
     }
 
-    static void OnSuccessCallback_113(void * context, uint64_t epochUs)
+    static void OnFailureCallback_113(void * context, EmberAfStatus status)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_113(epochUs);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_113(chip::to_underlying(status));
     }
 
+    static void OnSuccessCallback_113(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_113(); }
+
     static void OnFailureCallback_114(void * context, uint8_t status)
     {
         (static_cast<TestCluster *>(context))->OnFailureResponse_114(status);
     }
 
-    static void OnSuccessCallback_114(void * context, uint32_t epochS)
+    static void OnSuccessCallback_114(void * context, uint64_t epochUs)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_114(epochS);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_114(epochUs);
     }
 
     static void OnFailureCallback_115(void * context, EmberAfStatus status)
@@ -23377,36 +23383,36 @@ class TestCluster : public TestCommand
         (static_cast<TestCluster *>(context))->OnFailureResponse_116(status);
     }
 
-    static void OnSuccessCallback_116(void * context, uint32_t epochS)
+    static void OnSuccessCallback_116(void * context, uint64_t epochUs)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_116(epochS);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_116(epochUs);
     }
 
-    static void OnFailureCallback_117(void * context, EmberAfStatus status)
+    static void OnFailureCallback_117(void * context, uint8_t status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_117(chip::to_underlying(status));
+        (static_cast<TestCluster *>(context))->OnFailureResponse_117(status);
     }
 
-    static void OnSuccessCallback_117(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_117(); }
-
-    static void OnFailureCallback_118(void * context, uint8_t status)
+    static void OnSuccessCallback_117(void * context, uint32_t epochS)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_118(status);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_117(epochS);
     }
 
-    static void OnSuccessCallback_118(void * context, uint32_t epochS)
+    static void OnFailureCallback_118(void * context, EmberAfStatus status)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_118(epochS);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_118(chip::to_underlying(status));
     }
 
+    static void OnSuccessCallback_118(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_118(); }
+
     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, uint32_t epochS)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_119(unsupported);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_119(epochS);
     }
 
     static void OnFailureCallback_120(void * context, EmberAfStatus status)
@@ -23416,14 +23422,24 @@ class TestCluster : public TestCommand
 
     static void OnSuccessCallback_120(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_120(); }
 
+    static void OnFailureCallback_121(void * context, uint8_t status)
+    {
+        (static_cast<TestCluster *>(context))->OnFailureResponse_121(status);
+    }
+
+    static void OnSuccessCallback_121(void * context, uint32_t epochS)
+    {
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_121(epochS);
+    }
+
     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 void OnSuccessCallback_122(void * context, bool unsupported)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_122(vendorId);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_122(unsupported);
     }
 
     static void OnFailureCallback_123(void * context, EmberAfStatus status)
@@ -23433,22 +23449,39 @@ class TestCluster : public TestCommand
 
     static void OnSuccessCallback_123(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_123(); }
 
-    static void OnFailureCallback_124(void * context, uint8_t status)
+    static void OnFailureCallback_125(void * context, uint8_t status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_124(status);
+        (static_cast<TestCluster *>(context))->OnFailureResponse_125(status);
     }
 
-    static void OnSuccessCallback_124(void * context, chip::VendorId vendorId)
+    static void OnSuccessCallback_125(void * context, chip::VendorId vendorId)
     {
-        (static_cast<TestCluster *>(context))->OnSuccessResponse_124(vendorId);
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_125(vendorId);
     }
 
-    static void OnFailureCallback_125(void * context, EmberAfStatus status)
+    static void OnFailureCallback_126(void * context, EmberAfStatus status)
+    {
+        (static_cast<TestCluster *>(context))->OnFailureResponse_126(chip::to_underlying(status));
+    }
+
+    static void OnSuccessCallback_126(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_126(); }
+
+    static void OnFailureCallback_127(void * context, uint8_t status)
     {
-        (static_cast<TestCluster *>(context))->OnFailureResponse_125(chip::to_underlying(status));
+        (static_cast<TestCluster *>(context))->OnFailureResponse_127(status);
     }
 
-    static void OnSuccessCallback_125(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_125(); }
+    static void OnSuccessCallback_127(void * context, chip::VendorId vendorId)
+    {
+        (static_cast<TestCluster *>(context))->OnSuccessResponse_127(vendorId);
+    }
+
+    static void OnFailureCallback_128(void * context, EmberAfStatus status)
+    {
+        (static_cast<TestCluster *>(context))->OnFailureResponse_128(chip::to_underlying(status));
+    }
+
+    static void OnSuccessCallback_128(void * context) { (static_cast<TestCluster *>(context))->OnSuccessResponse_128(); }
 
     //
     // Tests methods
@@ -25224,49 +25257,125 @@ class TestCluster : public TestCommand
 
     void OnSuccessResponse_105() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeList_106()
+    CHIP_ERROR TestWriteAttributeList_106()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeListInt8u(mOnSuccessCallback_106.Cancel(), mOnFailureCallback_106.Cancel());
+        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_106, OnFailureCallback_106);
     }
 
     void OnFailureResponse_106(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_106(const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)
+    void OnSuccessResponse_106() { NextTest(); }
+
+    CHIP_ERROR TestReadAttributeList_107()
+    {
+        chip::Controller::TestClusterClusterTest cluster;
+        cluster.Associate(mDevice, 1);
+
+        return cluster.ReadAttributeListInt8u(mOnSuccessCallback_107.Cancel(), mOnFailureCallback_107.Cancel());
+    }
+
+    void OnFailureResponse_107(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_107(const chip::app::DataModel::DecodableList<uint8_t> & listInt8u)
     {
         VerifyOrReturn(CheckValueAsListLength("listInt8u", listInt8u, 4));
         NextTest();
     }
 
-    CHIP_ERROR TestReadAttributeListOctetString_107()
+    CHIP_ERROR TestWriteAttributeListOctetString_108()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeListOctetString(mOnSuccessCallback_107.Cancel(), mOnFailureCallback_107.Cancel());
+        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_108, OnFailureCallback_108);
     }
 
-    void OnFailureResponse_107(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_108(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_108() { NextTest(); }
+
+    CHIP_ERROR TestReadAttributeListOctetString_109()
+    {
+        chip::Controller::TestClusterClusterTest cluster;
+        cluster.Associate(mDevice, 1);
+
+        return cluster.ReadAttributeListOctetString(mOnSuccessCallback_109.Cancel(), mOnFailureCallback_109.Cancel());
+    }
+
+    void OnFailureResponse_109(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_107(const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)
+    void OnSuccessResponse_109(const chip::app::DataModel::DecodableList<chip::ByteSpan> & listOctetString)
     {
         VerifyOrReturn(CheckValueAsListLength("listOctetString", listOctetString, 4));
         NextTest();
     }
 
-    CHIP_ERROR TestReadAttributeListStructOctetString_108()
+    CHIP_ERROR TestWriteAttributeListStructOctetString_110()
+    {
+        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_110, OnFailureCallback_110);
+    }
+
+    void OnFailureResponse_110(uint8_t status) { ThrowFailureResponse(); }
+
+    void OnSuccessResponse_110() { NextTest(); }
+
+    CHIP_ERROR TestReadAttributeListStructOctetString_111()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeListStructOctetString(mOnSuccessCallback_108.Cancel(), mOnFailureCallback_108.Cancel());
+        return cluster.ReadAttributeListStructOctetString(mOnSuccessCallback_111.Cancel(), mOnFailureCallback_111.Cancel());
     }
 
-    void OnFailureResponse_108(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_111(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_108(
+    void OnSuccessResponse_111(
         const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
             listStructOctetString)
     {
@@ -25274,23 +25383,23 @@ class TestCluster : public TestCommand
         NextTest();
     }
 
-    CHIP_ERROR TestReadAttributeEpochUsDefaultValue_109()
+    CHIP_ERROR TestReadAttributeEpochUsDefaultValue_112()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_109.Cancel(), mOnFailureCallback_109.Cancel());
+        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_112.Cancel(), mOnFailureCallback_112.Cancel());
     }
 
-    void OnFailureResponse_109(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_112(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_109(uint64_t epochUs)
+    void OnSuccessResponse_112(uint64_t epochUs)
     {
         VerifyOrReturn(CheckValue<uint64_t>("epochUs", epochUs, 0ULL));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeEpochUsMaxValue_110()
+    CHIP_ERROR TestWriteAttributeEpochUsMaxValue_113()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25299,30 +25408,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_113, OnFailureCallback_113);
     }
 
-    void OnFailureResponse_110(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_113(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_110() { NextTest(); }
+    void OnSuccessResponse_113() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeEpochUsMaxValue_111()
+    CHIP_ERROR TestReadAttributeEpochUsMaxValue_114()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_111.Cancel(), mOnFailureCallback_111.Cancel());
+        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_114.Cancel(), mOnFailureCallback_114.Cancel());
     }
 
-    void OnFailureResponse_111(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_114(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_111(uint64_t epochUs)
+    void OnSuccessResponse_114(uint64_t epochUs)
     {
         VerifyOrReturn(CheckValue<uint64_t>("epochUs", epochUs, 18446744073709551615ULL));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeEpochUsMinValue_112()
+    CHIP_ERROR TestWriteAttributeEpochUsMinValue_115()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25331,46 +25440,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_115, OnFailureCallback_115);
     }
 
-    void OnFailureResponse_112(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_115(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_112() { NextTest(); }
+    void OnSuccessResponse_115() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeEpochUsMinValue_113()
+    CHIP_ERROR TestReadAttributeEpochUsMinValue_116()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_113.Cancel(), mOnFailureCallback_113.Cancel());
+        return cluster.ReadAttributeEpochUs(mOnSuccessCallback_116.Cancel(), mOnFailureCallback_116.Cancel());
     }
 
-    void OnFailureResponse_113(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_116(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_113(uint64_t epochUs)
+    void OnSuccessResponse_116(uint64_t epochUs)
     {
         VerifyOrReturn(CheckValue<uint64_t>("epochUs", epochUs, 0ULL));
         NextTest();
     }
 
-    CHIP_ERROR TestReadAttributeEpochSDefaultValue_114()
+    CHIP_ERROR TestReadAttributeEpochSDefaultValue_117()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochS(mOnSuccessCallback_114.Cancel(), mOnFailureCallback_114.Cancel());
+        return cluster.ReadAttributeEpochS(mOnSuccessCallback_117.Cancel(), mOnFailureCallback_117.Cancel());
     }
 
-    void OnFailureResponse_114(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_117(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_114(uint32_t epochS)
+    void OnSuccessResponse_117(uint32_t epochS)
     {
         VerifyOrReturn(CheckValue<uint32_t>("epochS", epochS, 0UL));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeEpochSMaxValue_115()
+    CHIP_ERROR TestWriteAttributeEpochSMaxValue_118()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25379,30 +25488,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_118, OnFailureCallback_118);
     }
 
-    void OnFailureResponse_115(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_118(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_115() { NextTest(); }
+    void OnSuccessResponse_118() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeEpochSMaxValue_116()
+    CHIP_ERROR TestReadAttributeEpochSMaxValue_119()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochS(mOnSuccessCallback_116.Cancel(), mOnFailureCallback_116.Cancel());
+        return cluster.ReadAttributeEpochS(mOnSuccessCallback_119.Cancel(), mOnFailureCallback_119.Cancel());
     }
 
-    void OnFailureResponse_116(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_119(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_116(uint32_t epochS)
+    void OnSuccessResponse_119(uint32_t epochS)
     {
         VerifyOrReturn(CheckValue<uint32_t>("epochS", epochS, 4294967295UL));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeEpochSMinValue_117()
+    CHIP_ERROR TestWriteAttributeEpochSMinValue_120()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25411,49 +25520,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_120, OnFailureCallback_120);
     }
 
-    void OnFailureResponse_117(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_120(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_117() { NextTest(); }
+    void OnSuccessResponse_120() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeEpochSMinValue_118()
+    CHIP_ERROR TestReadAttributeEpochSMinValue_121()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeEpochS(mOnSuccessCallback_118.Cancel(), mOnFailureCallback_118.Cancel());
+        return cluster.ReadAttributeEpochS(mOnSuccessCallback_121.Cancel(), mOnFailureCallback_121.Cancel());
     }
 
-    void OnFailureResponse_118(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_121(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_118(uint32_t epochS)
+    void OnSuccessResponse_121(uint32_t epochS)
     {
         VerifyOrReturn(CheckValue<uint32_t>("epochS", epochS, 0UL));
         NextTest();
     }
 
-    CHIP_ERROR TestReadAttributeUnsupported_119()
+    CHIP_ERROR TestReadAttributeUnsupported_122()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeUnsupported(mOnSuccessCallback_119.Cancel(), mOnFailureCallback_119.Cancel());
+        return cluster.ReadAttributeUnsupported(mOnSuccessCallback_122.Cancel(), mOnFailureCallback_122.Cancel());
     }
 
-    void OnFailureResponse_119(uint8_t status)
+    void OnFailureResponse_122(uint8_t status)
     {
         (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) ? NextTest() : ThrowFailureResponse();
     }
 
-    void OnSuccessResponse_119(bool unsupported)
+    void OnSuccessResponse_122(bool unsupported)
     {
         VerifyOrReturn(CheckValue<bool>("unsupported", unsupported, 0));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteattributeUnsupported_120()
+    CHIP_ERROR TestWriteattributeUnsupported_123()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25462,17 +25571,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_123, OnFailureCallback_123);
     }
 
-    void OnFailureResponse_120(uint8_t status)
+    void OnFailureResponse_123(uint8_t status)
     {
         (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) ? NextTest() : ThrowFailureResponse();
     }
 
-    void OnSuccessResponse_120() { NextTest(); }
+    void OnSuccessResponse_123() { NextTest(); }
 
-    CHIP_ERROR TestSendTestCommandToUnsupportedEndpoint_121()
+    CHIP_ERROR TestSendTestCommandToUnsupportedEndpoint_124()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 200);
@@ -25483,36 +25592,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_124();
         };
 
         auto failure = [](void * context, EmberAfStatus status) {
-            (static_cast<TestCluster *>(context))->OnFailureResponse_121(status);
+            (static_cast<TestCluster *>(context))->OnFailureResponse_124(status);
         };
         return cluster.InvokeCommand<requestType, responseType>(request, this, success, failure);
     }
 
-    void OnFailureResponse_121(uint8_t status) { NextTest(); }
+    void OnFailureResponse_124(uint8_t status) { NextTest(); }
 
-    void OnSuccessResponse_121() { ThrowSuccessResponse(); }
+    void OnSuccessResponse_124() { ThrowSuccessResponse(); }
 
-    CHIP_ERROR TestReadAttributeVendorIdDefaultValue_122()
+    CHIP_ERROR TestReadAttributeVendorIdDefaultValue_125()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeVendorId(mOnSuccessCallback_122.Cancel(), mOnFailureCallback_122.Cancel());
+        return cluster.ReadAttributeVendorId(mOnSuccessCallback_125.Cancel(), mOnFailureCallback_125.Cancel());
     }
 
-    void OnFailureResponse_122(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_125(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_122(chip::VendorId vendorId)
+    void OnSuccessResponse_125(chip::VendorId vendorId)
     {
         VerifyOrReturn(CheckValue<chip::VendorId>("vendorId", vendorId, 0U));
         NextTest();
     }
 
-    CHIP_ERROR TestWriteAttributeVendorId_123()
+    CHIP_ERROR TestWriteAttributeVendorId_126()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25521,30 +25630,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_126, OnFailureCallback_126);
     }
 
-    void OnFailureResponse_123(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_126(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_123() { NextTest(); }
+    void OnSuccessResponse_126() { NextTest(); }
 
-    CHIP_ERROR TestReadAttributeVendorId_124()
+    CHIP_ERROR TestReadAttributeVendorId_127()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
 
-        return cluster.ReadAttributeVendorId(mOnSuccessCallback_124.Cancel(), mOnFailureCallback_124.Cancel());
+        return cluster.ReadAttributeVendorId(mOnSuccessCallback_127.Cancel(), mOnFailureCallback_127.Cancel());
     }
 
-    void OnFailureResponse_124(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_127(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_124(chip::VendorId vendorId)
+    void OnSuccessResponse_127(chip::VendorId vendorId)
     {
         VerifyOrReturn(CheckValue<chip::VendorId>("vendorId", vendorId, 17U));
         NextTest();
     }
 
-    CHIP_ERROR TestRestoreAttributeVendorId_125()
+    CHIP_ERROR TestRestoreAttributeVendorId_128()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25553,14 +25662,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_128, OnFailureCallback_128);
     }
 
-    void OnFailureResponse_125(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_128(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_125() { NextTest(); }
+    void OnSuccessResponse_128() { NextTest(); }
 
-    CHIP_ERROR TestSendACommandWithAVendorIdAndEnum_126()
+    CHIP_ERROR TestSendACommandWithAVendorIdAndEnum_129()
     {
         chip::Controller::TestClusterClusterTest cluster;
         cluster.Associate(mDevice, 1);
@@ -25573,18 +25682,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_129(data.arg1, data.arg2);
         };
 
         auto failure = [](void * context, EmberAfStatus status) {
-            (static_cast<TestCluster *>(context))->OnFailureResponse_126(status);
+            (static_cast<TestCluster *>(context))->OnFailureResponse_129(status);
         };
         return cluster.InvokeCommand<requestType, responseType>(request, this, success, failure);
     }
 
-    void OnFailureResponse_126(uint8_t status) { ThrowFailureResponse(); }
+    void OnFailureResponse_129(uint8_t status) { ThrowFailureResponse(); }
 
-    void OnSuccessResponse_126(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2)
+    void OnSuccessResponse_129(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2)
     {
         VerifyOrReturn(CheckValue<chip::VendorId>("arg1", arg1, 20003U));
 
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