diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 7c259cc77..11f1b73d7 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -588,6 +588,7 @@ build_managed_component_light:
 build_esp_rainmaker_apps:
     stage: build
     image: ${DOCKER_IMAGE_NAME}:chip_${CHIP_SHORT_HASH}_idf_${IDF_CHECKOUT_REF}
+    # Allow failures to avoid circular dependency with any breaking changes in the Esp-Matter SDK.
     allow_failure: true
 
     tags:
diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 97894d396..e518f5548 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -1,3 +1,10 @@
+# 3-Feb-2024
+
+Cluster structure change.
+  - `feature_flags` are now part of `cluster::config` to configure the features in the application.
+  - moved `features::config` frome `cluster::config` to `cluster::config::features` structure.
+
+
 # 27-December-2024
 
 Added ``matter esp factoryreset`` command to factory reset a Matter device.
diff --git a/components/esp_matter/esp_matter_attribute.cpp b/components/esp_matter/esp_matter_attribute.cpp
index c1bd45039..52bae1392 100644
--- a/components/esp_matter/esp_matter_attribute.cpp
+++ b/components/esp_matter/esp_matter_attribute.cpp
@@ -2221,6 +2221,12 @@ attribute_t *create_ac_capacity_format(cluster_t *cluster, uint8_t value)
                                          ATTRIBUTE_FLAG_NONVOLATILE | ATTRIBUTE_FLAG_WRITABLE, esp_matter_uint8(value));
 }
 
+attribute_t *create_preset_types(cluster_t *cluster, uint8_t * value, uint16_t length, uint16_t count)
+{
+    return esp_matter::attribute::create(cluster, Thermostat::Attributes::PresetTypes::Id, ATTRIBUTE_FLAG_NONE | ATTRIBUTE_FLAG_MANAGED_INTERNALLY,
+                                         esp_matter_array(value, length, count));
+}
+
 attribute_t *create_schedule_type(cluster_t *cluster, uint8_t * value, uint16_t length, uint16_t count)
 {
     return esp_matter::attribute::create(cluster, Thermostat::Attributes::ScheduleTypes::Id, ATTRIBUTE_FLAG_NONE | ATTRIBUTE_FLAG_MANAGED_INTERNALLY,
diff --git a/components/esp_matter/esp_matter_attribute.h b/components/esp_matter/esp_matter_attribute.h
index 882870597..9841e9af9 100644
--- a/components/esp_matter/esp_matter_attribute.h
+++ b/components/esp_matter/esp_matter_attribute.h
@@ -522,7 +522,7 @@ attribute_t *create_ac_error_code(cluster_t *cluster, uint32_t value);
 attribute_t *create_ac_louver_position(cluster_t *cluster, uint8_t value);
 attribute_t *create_ac_coil_temperature(cluster_t *cluster, nullable<int16_t> value);
 attribute_t *create_ac_capacity_format(cluster_t *cluster, uint8_t value);
-attribute_t *create_preset_type(cluster_t *cluster, uint8_t * value, uint16_t length, uint16_t count);
+attribute_t *create_preset_types(cluster_t *cluster, uint8_t * value, uint16_t length, uint16_t count);
 attribute_t *create_schedule_type(cluster_t *cluster, uint8_t * value, uint16_t length, uint16_t count);
 attribute_t *create_number_of_presets(cluster_t *cluster, uint8_t value);
 attribute_t *create_number_of_schedules(cluster_t *cluster, uint8_t value);
diff --git a/components/esp_matter/esp_matter_cluster.cpp b/components/esp_matter/esp_matter_cluster.cpp
index 86887a26c..be0958ff6 100644
--- a/components/esp_matter/esp_matter_cluster.cpp
+++ b/components/esp_matter/esp_matter_cluster.cpp
@@ -141,7 +141,7 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
     }
 
      /* Features */
-    if (config != NULL && config->features & feature::taglist::get_id()) {
+    if (config && config->feature_flags & feature::taglist::get_id()) {
         feature::taglist::add(cluster);
     }
 
@@ -207,6 +207,16 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 
     event::create_access_control_entry_changed(cluster);
 
+    /* Features */
+    if (config) {
+        if (config->feature_flags & feature::extension::get_id()) {
+            feature::extension::add(cluster);
+        }
+        if (config->feature_flags & feature::managed_device::get_id()) {
+            feature::managed_device::add(cluster);
+        }
+    }
+
     return cluster;
 }
 } /* access_control */
@@ -392,6 +402,11 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         }
     }
 
+    /* Features */
+    if (config && config->feature_flags & feature::terms_and_conditions::get_id()) {
+        feature::terms_and_conditions::add(cluster, &(config->features.terms_and_conditions));
+    }
+
     return cluster;
 }
 } /* general_commissioning */
@@ -504,8 +519,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
         global::attribute::create_cluster_revision(cluster, cluster_revision);
     }
 
-     /* Features */
-    if (features & feature::basic::get_id()) {
+    /* Features */
+    if (config && config->feature_flags & feature::basic::get_id()) {
         feature::basic::add(cluster);
     }
 
@@ -600,6 +615,16 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         global::attribute::create_cluster_revision(cluster, cluster_revision);
     }
 
+    /* Features */
+    if (config) {
+        if (config->feature_flags & feature::packet_counts::get_id()) {
+            feature::packet_counts::add(cluster);
+        }
+        if (config->feature_flags & feature::error_counts::get_id()) {
+            feature::error_counts::add(cluster);
+        }
+    }
+
     return cluster;
 }
 } /* wifi_network_diagnostics */
@@ -668,6 +693,16 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         global::attribute::create_cluster_revision(cluster, cluster_revision);
     }
 
+    /* Features */
+    if (config) {
+        if (config->feature_flags & feature::packet_counts::get_id()) {
+            feature::packet_counts::add(cluster, &(config->features.packet_counts));
+        }
+        if (config->feature_flags & feature::error_counts::get_id()) {
+            feature::error_counts::add(cluster, &(config->features.error_counts));
+        }
+    }
+
     return cluster;
 }
 } /* ethernet_network_diagnostics */
@@ -705,6 +740,20 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 
     event::create_time_failure(cluster);
 
+    if(config) {
+        if(config->feature_flags & feature::time_zone::get_id()) {
+            feature::time_zone::add(cluster, &(config->features.time_zone));
+        }
+        if(config->feature_flags & feature::ntp_client::get_id()) {
+            feature::ntp_client::add(cluster, &(config->features.ntp_client));
+        }
+        if(config->feature_flags & feature::ntp_server::get_id()) {
+            feature::ntp_server::add(cluster, &(config->features.ntp_server));
+        }
+        if(config->feature_flags & feature::time_sync_client::get_id()) {
+            feature::time_sync_client::add(cluster);
+        }
+    }
     return cluster;
 }
 } /* time_synchronization */
@@ -729,8 +778,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if (features & feature::temperature_unit::get_id()) {
-        feature::temperature_unit::add(cluster, &(config->temperature_unit));
+    if (config && config->feature_flags & feature::temperature_unit::get_id()) {
+        feature::temperature_unit::add(cluster, &(config->features.temperature_unit));
     }
 
     return cluster;
@@ -766,6 +815,11 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 
     event::create_reachable_changed(cluster);
 
+    /* Features */
+    if (config && config->feature_flags & feature::bridged_icd_support::get_id()) {
+        feature::bridged_icd_support::add(cluster);
+    }
+
     return cluster;
 }
 } /* bridged_device_basic_information */
@@ -799,20 +853,22 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if (features & feature::wired::get_id()) {
-        feature::wired::add(cluster, &(config->wired));
-    }
+    if(config) {
+        if (config->feature_flags & feature::wired::get_id()) {
+            feature::wired::add(cluster, &(config->features.wired));
+        }
 
-    if (features & feature::battery::get_id()) {
-        feature::battery::add(cluster, &(config->battery));
-    }
+        if (config->feature_flags & feature::battery::get_id()) {
+            feature::battery::add(cluster, &(config->features.battery));
+        }
 
-    if (features & feature::rechargeable::get_id()) {
-        feature::rechargeable::add(cluster, &(config->rechargeable));
-    }
+        if (config->feature_flags & feature::rechargeable::get_id()) {
+            feature::rechargeable::add(cluster, &(config->features.rechargeable));
+        }
 
-    if (features & feature::replaceable::get_id()) {
-        feature::replaceable::add(cluster, &(config->replaceable));
+        if (config->feature_flags & feature::replaceable::get_id()) {
+            feature::replaceable::add(cluster, &(config->features.replaceable));
+        }
     }
 
     return cluster;
@@ -844,13 +900,15 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
 #if defined(CHIP_CONFIG_ENABLE_ICD_CIP) && CHIP_CONFIG_ENABLE_ICD_CIP
-    if (features & feature::long_idle_time_support::get_id()) {
-        feature::long_idle_time_support::add(cluster);
-        if (features & feature::user_active_mode_trigger::get_id()) {
-            feature::user_active_mode_trigger::add(cluster, &config->user_active_mode_trigger);
-        }
-        if (features & feature::check_in_protocol_support::get_id()) {
-            feature::check_in_protocol_support::add(cluster);
+    if(config) {
+        if (config->feature_flags & feature::long_idle_time_support::get_id()) {
+            feature::long_idle_time_support::add(cluster);
+            if (config->feature_flags & feature::user_active_mode_trigger::get_id()) {
+                feature::user_active_mode_trigger::add(cluster, &config->features.user_active_mode_trigger);
+            }
+            if (config->feature_flags & feature::check_in_protocol_support::get_id()) {
+                feature::check_in_protocol_support::add(cluster);
+            }
         }
     }
 #endif // defined(CHIP_CONFIG_ENABLE_ICD_CIP) && CHIP_CONFIG_ENABLE_ICD_CIP
@@ -1042,6 +1100,22 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
     command::create_store_scene_response(cluster);
     command::create_get_scene_membership_response(cluster);
 
+    /* Features */
+    if(config) {
+        if (config->feature_flags & feature::scene_names::get_id()) {
+            feature::scene_names::add(cluster);
+        }
+        if (config->feature_flags & feature::explicit_feature::get_id()) {
+            feature::explicit_feature::add(cluster);
+        }
+        if (config->feature_flags & feature::table_size::get_id()) {
+            feature::table_size::add(cluster);
+        }
+        if (config->feature_flags & feature::fabric_scenes::get_id()) {
+            feature::fabric_scenes::add(cluster);
+        }
+    }
+
     return cluster;
 }
 } /* scenes_management */
@@ -1076,24 +1150,26 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
         }
     }
 
-    /* Features */
-    if (features & feature::off_only::get_id()) {
-        feature::off_only::add(cluster);
-    }
-    else {
-        if (features & feature::lighting::get_id()) {
-            feature::lighting::add(cluster, &(config->lighting));
-        }
-        if (features & feature::dead_front_behavior::get_id()) {
-            feature::dead_front_behavior::add(cluster);
-        }
-    }
-
     /* Commands */
     command::create_off(cluster);
-    if (!(features & feature::off_only::get_id())) {
-        command::create_on(cluster);
-        command::create_toggle(cluster);
+
+    /* Features */
+    if (config) {
+        if (config->feature_flags & feature::off_only::get_id()) {
+            feature::off_only::add(cluster);
+        }
+        else {
+            if (config->feature_flags & feature::lighting::get_id()) {
+                feature::lighting::add(cluster, &(config->features.lighting));
+            }
+            if (config->feature_flags & feature::dead_front_behavior::get_id()) {
+                feature::dead_front_behavior::add(cluster);
+            }
+        }
+        if (!(config->feature_flags & feature::off_only::get_id())) {
+            command::create_on(cluster);
+            command::create_toggle(cluster);
+        }
     }
 
     return cluster;
@@ -1143,11 +1219,16 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     command::create_stop_with_on_off(cluster);
 
     /* Features */
-    if (features & feature::on_off::get_id()) {
-        feature::on_off::add(cluster);
-    }
-    if (features & feature::lighting::get_id()) {
-        feature::lighting::add(cluster, &(config->lighting));
+    if (config) {
+        if (config->feature_flags & feature::on_off::get_id()) {
+            feature::on_off::add(cluster);
+        }
+        if (config->feature_flags & feature::lighting::get_id()) {
+            feature::lighting::add(cluster, &(config->features.lighting));
+        }
+        if (config->feature_flags & feature::frequency::get_id()) {
+            feature::frequency::add(cluster, &(config->features.frequency));
+        }
     }
 
     return cluster;
@@ -1197,25 +1278,27 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Commands */
-    if (features & feature::hue_saturation::get_id() || features & feature::color_temperature::get_id() || features & feature::xy::get_id()) {
-        command::create_stop_move_step(cluster);
-    }
+    if(config) {
+        if (config->feature_flags & feature::hue_saturation::get_id() || config->feature_flags & feature::color_temperature::get_id() || config->feature_flags & feature::xy::get_id()) {
+            command::create_stop_move_step(cluster);
+        }
 
-    /* Features */
-    if (features & feature::hue_saturation::get_id()) {
-        feature::hue_saturation::add(cluster, &(config->hue_saturation));
-    }
-    if (features & feature::color_temperature::get_id()) {
-        feature::color_temperature::add(cluster, &(config->color_temperature));
-    }
-    if (features & feature::xy::get_id()) {
-        feature::xy::add(cluster, &(config->xy));
-    }
-    if (features & feature::enhanced_hue::get_id()) {
-        feature::enhanced_hue::add(cluster, &(config->enhanced_hue));
-    }
-    if (features & feature::color_loop::get_id()) {
-        feature::color_loop::add(cluster, &(config->color_loop));
+        /* Features */
+        if (config->feature_flags & feature::hue_saturation::get_id()) {
+            feature::hue_saturation::add(cluster, &(config->features.hue_saturation));
+        }
+        if (config->feature_flags & feature::color_temperature::get_id()) {
+            feature::color_temperature::add(cluster, &(config->features.color_temperature));
+        }
+        if (config->feature_flags & feature::xy::get_id()) {
+            feature::xy::add(cluster, &(config->features.xy));
+        }
+        if (config->feature_flags & feature::enhanced_hue::get_id()) {
+            feature::enhanced_hue::add(cluster, &(config->features.enhanced_hue));
+        }
+        if (config->feature_flags & feature::color_loop::get_id()) {
+            feature::color_loop::add(cluster, &(config->features.color_loop));
+        }
     }
 
     return cluster;
@@ -1263,6 +1346,28 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         create_default_binding_cluster(endpoint);
     }
 
+    /* Features */
+    if(config) {
+        if (config->feature_flags & feature::multi_speed::get_id()) {
+            feature::multi_speed::add(cluster, &(config->features.multi_speed));
+        }
+        if (config->feature_flags & feature::fan_auto::get_id()) {
+            feature::fan_auto::add(cluster);
+        }
+        if (config->feature_flags & feature::rocking::get_id()) {
+            feature::rocking::add(cluster, &(config->features.rocking));
+        }
+        if (config->feature_flags & feature::wind::get_id()) {
+            feature::wind::add(cluster, &(config->features.wind));
+        }
+        if (config->feature_flags & feature::step::get_id()) {
+            feature::step::add(cluster);
+        }
+        if (config->feature_flags & feature::airflow_direction::get_id()) {
+            feature::airflow_direction::add(cluster, &(config->features.airflow_direction));
+        }
+    }
+
     return cluster;
 }
 } /* fan_control */
@@ -1307,29 +1412,34 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     command::create_setpoint_raise_lower(cluster);
 
     /* Features */
-    if (!(features & (feature::heating::get_id() | feature::cooling::get_id()))) {
-        ESP_LOGE(TAG, "Cluster shall support at least one of heating or cooling features.");
-    }
-    if (features & feature::heating::get_id()) {
-        feature::heating::add(cluster, &(config->heating));
-    }
-    if (features & feature::cooling::get_id()) {
-        feature::cooling::add(cluster, &(config->cooling));
-    }
-    if (features & feature::setback::get_id()) {
-        feature::setback::add(cluster, &(config->setback));
-    }
-    if (features & feature::occupancy::get_id()) {
-        feature::occupancy::add(cluster, &(config->occupancy));
-    }
-    if (features & feature::schedule_configuration::get_id()) {
-        feature::schedule_configuration::add(cluster, &(config->schedule_configuration));
-    }
-    if (features & feature::auto_mode::get_id()) {
-        feature::auto_mode::add(cluster, &(config->auto_mode));
-    }
-    if (features & feature::local_temperature_not_exposed::get_id()) {
-        feature::local_temperature_not_exposed::add(cluster, &(config->local_temperature_not_exposed));
+    if(config) {
+        if (!(config->feature_flags & (feature::heating::get_id() | feature::cooling::get_id()))) {
+            ESP_LOGE(TAG, "Cluster shall support at least one of heating or cooling features.");
+        }
+        if (config->feature_flags & feature::heating::get_id()) {
+            feature::heating::add(cluster, &(config->features.heating));
+        }
+        if (config->feature_flags & feature::cooling::get_id()) {
+            feature::cooling::add(cluster, &(config->features.cooling));
+        }
+        if (config->feature_flags & feature::setback::get_id()) {
+            feature::setback::add(cluster, &(config->features.setback));
+        }
+        if (config->feature_flags & feature::occupancy::get_id()) {
+            feature::occupancy::add(cluster, &(config->features.occupancy));
+        }
+        if (config->feature_flags & feature::auto_mode::get_id()) {
+            feature::auto_mode::add(cluster, &(config->features.auto_mode));
+        }
+        if (config->feature_flags & feature::local_temperature_not_exposed::get_id()) {
+            feature::local_temperature_not_exposed::add(cluster, &(config->features.local_temperature_not_exposed));
+        }
+        if (config->feature_flags & feature::matter_schedule_configuration::get_id()) {
+            feature::matter_schedule_configuration::add(cluster, &(config->features.matter_schedule_configuration));
+        }
+        if (config->feature_flags & feature::presets::get_id()) {
+            feature::presets::add(cluster);
+        }
     }
     return cluster;
 }
@@ -1396,6 +1506,21 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         create_default_binding_cluster(endpoint);
     }
 
+    /* Features */
+    if(config) {
+        if(config->feature_flags & feature::fair::get_id()) {
+            feature::fair::add(cluster);
+        }
+        if(config->feature_flags & feature::moderate::get_id()) {
+            feature::moderate::add(cluster);
+        }
+        if(config->feature_flags & feature::very_poor::get_id()) {
+            feature::very_poor::add(cluster);
+        }
+        if(config->feature_flags & feature::extremely_poor::get_id()) {
+            feature::extremely_poor::add(cluster);
+        }
+    }
     return cluster;
 }
 } /* air_quality */
@@ -1429,6 +1554,17 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         create_default_binding_cluster(endpoint);
     }
 
+    if(config) {
+        if(config->feature_flags & feature::condition::get_id()) {
+            feature::condition::add(cluster, &(config->features.condition));
+        }
+        if(config->feature_flags & feature::warning::get_id()) {
+            feature::warning::add(cluster);
+        }
+        if(config->feature_flags & feature::replacement_product_list::get_id()) {
+            feature::replacement_product_list::add(cluster);
+        }
+    }
     return cluster;
 }
 } /* hepa_filter_monitoring */
@@ -1462,6 +1598,17 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         create_default_binding_cluster(endpoint);
     }
 
+    if(config) {
+        if(config->feature_flags & feature::condition::get_id()) {
+            feature::condition::add(cluster, &(config->features.condition));
+        }
+        if(config->feature_flags & feature::warning::get_id()) {
+            feature::warning::add(cluster);
+        }
+        if(config->feature_flags & feature::replacement_product_list::get_id()) {
+            feature::replacement_product_list::add(cluster);
+        }
+    }
     return cluster;
 }
 } /* activated_carbon_filter_monitoring */
@@ -1502,8 +1649,29 @@ namespace  carbon_monoxide_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        CarbonMonoxideConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* carbon_monoxide_concentration_measurement */
@@ -1512,8 +1680,29 @@ namespace  carbon_dioxide_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        CarbonDioxideConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* carbon_dioxide_concentration_measurement */
@@ -1522,8 +1711,29 @@ namespace  nitrogen_dioxide_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        NitrogenDioxideConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* nitrogen_dioxide_concentration_measurement */
@@ -1532,8 +1742,29 @@ namespace  ozone_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        OzoneConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* ozone_concentration_measurement */
@@ -1542,8 +1773,29 @@ namespace  formaldehyde_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        FormaldehydeConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* formaldehyde_concentration_measurement */
@@ -1552,8 +1804,29 @@ namespace  pm1_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        Pm1ConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* pm1_concentration_measurement */
@@ -1562,8 +1835,29 @@ namespace  pm25_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        Pm25ConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* pm25_concentration_measurement */
@@ -1572,8 +1866,29 @@ namespace  pm10_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        Pm10ConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* pm10_concentration_measurement */
@@ -1582,8 +1897,29 @@ namespace  radon_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags,
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags,
                                                        RadonConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* radon_concentration_measurement */
@@ -1592,7 +1928,28 @@ namespace  total_volatile_organic_compounds_concentration_measurement {
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {
-    return concentration_measurement::create<config_t>(endpoint, config, flags, TotalVolatileOrganicCompoundsConcentrationMeasurement::Id, cluster_revision);
+    cluster_t *cluster = concentration_measurement::create<config_t>(endpoint, config, flags, TotalVolatileOrganicCompoundsConcentrationMeasurement::Id, cluster_revision);
+    if(config) {
+        if(config->feature_flags & feature::numeric_measurement::get_id()) {
+            feature::numeric_measurement::add(cluster, &(config->features.numeric_measurement));
+        }
+        if(config->feature_flags & feature::level_indication::get_id()) {
+            feature::level_indication::add(cluster, &(config->features.level_indication));
+        }
+        if(config->feature_flags & feature::medium_level::get_id()) {
+            feature::medium_level::add(cluster);
+        }
+        if(config->feature_flags & feature::critical_level::get_id()) {
+            feature::critical_level::add(cluster);
+        }
+        if(config->feature_flags & feature::peak_measurement::get_id()) {
+            feature::peak_measurement::add(cluster, &(config->features.peak_measurement));
+        }
+        if(config->feature_flags & feature::average_measurement::get_id()) {
+            feature::average_measurement::add(cluster, &(config->features.average_measurement));
+        }
+    }
+    return cluster;
 }
 
 } /* total_volatile_organic_compounds_concentration_measurement */
@@ -1703,11 +2060,13 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
         create_default_binding_cluster(endpoint);
     }
 
-    if (features & feature::spin::get_id()) {
-        feature::spin::add(cluster, &(config->spin));
-    }
-    if (features & feature::rinse::get_id()) {
-        feature::rinse::add(cluster, &(config->rinse));
+    if(config) {
+        if (config->feature_flags & feature::spin::get_id()) {
+            feature::spin::add(cluster, &(config->features.spin));
+        }
+        if (config->feature_flags & feature::rinse::get_id()) {
+            feature::rinse::add(cluster, &(config->features.rinse));
+        }
     }
     return cluster;
 }
@@ -1856,7 +2215,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
     event::create_all_clear(cluster);
 
     /* Features */
-    feature::smoke_alarm::add(cluster);
+    if(config) {
+        if(config->feature_flags & feature::smoke_alarm::get_id()) {
+            feature::smoke_alarm::add(cluster);
+        }
+        if(config->feature_flags & feature::co_alarm::get_id()) {
+            feature::co_alarm::add(cluster);
+        }
+    }
 
     return cluster;
 }
@@ -1914,6 +2280,48 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
     command::create_lock_door(cluster);
     command::create_unlock_door(cluster);
 
+    /* Features */
+    if(config) {
+        if(config->feature_flags & feature::pin_credential::get_id()) {
+            feature::pin_credential::add(cluster, &(config->features.pin_credential));
+        }
+        if(config->feature_flags & feature::rfid_credential::get_id()) {
+            feature::rfid_credential::add(cluster, &(config->features.rfid_credential));
+        }
+        if(config->feature_flags & feature::finger_credentials::get_id()) {
+            feature::finger_credentials::add(cluster);
+        }
+        if(config->feature_flags & feature::weekday_access_schedules::get_id()) {
+            feature::weekday_access_schedules::add(cluster);
+        }
+        if(config->feature_flags & feature::door_position_sensor::get_id()) {
+            feature::door_position_sensor::add(cluster);
+        }
+        if(config->feature_flags & feature::face_credentials::get_id()) {
+            feature::face_credentials::add(cluster);
+        }
+        if(config->feature_flags & feature::credential_over_the_air_access::get_id()) {
+            feature::credential_over_the_air_access::add(cluster, &(config->features.credential_over_the_air_access));
+        }
+        if(config->feature_flags & feature::user::get_id()) {
+            feature::user::add(cluster, &(config->features.user));
+        }
+        if(config->feature_flags & feature::year_day_access_schedules::get_id()) {
+            feature::year_day_access_schedules::add(cluster);
+        }
+        if(config->feature_flags & feature::holiday_schedules::get_id()) {
+            feature::holiday_schedules::add(cluster);
+        }
+        if(config->feature_flags & feature::unbolting::get_id()) {
+            feature::unbolting::add(cluster);
+        }
+        if(config->feature_flags & feature::aliro_provisioning::get_id()) {
+            feature::aliro_provisioning::add(cluster);
+        }
+        if(config->feature_flags & feature::aliro_bleuwb::get_id()) {
+            feature::aliro_bleuwb::add(cluster);
+        }
+    }
     return cluster;
 }
 } /* door_lock */
@@ -1965,10 +2373,23 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     command::create_stop_motion(cluster);
 
     /* Features */
-    if (features & feature::lift::get_id()) {
-        feature::lift::add(cluster, &(config->lift));
+    if(config) {
+        if (config->feature_flags & feature::lift::get_id()) {
+            feature::lift::add(cluster, &(config->features.lift));
+        }
+        if (config->feature_flags & feature::tilt::get_id()) {
+            feature::tilt::add(cluster, &(config->features.tilt));
+        }
+        if (config->feature_flags & feature::position_aware_lift::get_id()) {
+            feature::position_aware_lift::add(cluster, &(config->features.position_aware_lift));
+        }
+        if (config->feature_flags & feature::absolute_position::get_id()) {
+            feature::absolute_position::add(cluster, &(config->features.absolute_position));
+        }
+        if (config->feature_flags & feature::position_aware_tilt::get_id()) {
+            feature::position_aware_tilt::add(cluster, &(config->features.position_aware_tilt));
+        }
     }
-
     return cluster;
 }
 } /* window_covering */
@@ -2004,6 +2425,26 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         create_default_binding_cluster(endpoint);
     }
 
+    if(config) {
+        if (config->feature_flags & feature::latching_switch::get_id()) {
+            feature::latching_switch::add(cluster);
+        }
+        if (config->feature_flags & feature::momentary_switch::get_id()) {
+            feature::momentary_switch::add(cluster);
+        }
+        if (config->feature_flags & feature::momentary_switch_release::get_id()) {
+            feature::momentary_switch_release::add(cluster);
+        }
+        if (config->feature_flags & feature::momentary_switch_long_press::get_id()) {
+            feature::momentary_switch_long_press::add(cluster);
+        }
+        if (config->feature_flags & feature::momentary_switch_multi_press::get_id()) {
+            feature::momentary_switch_multi_press::add(cluster, &(config->features.momentary_switch_multi_press));
+        }
+        if (config->feature_flags & feature::action_switch::get_id()) {
+            feature::action_switch::add(cluster);
+        }
+    }
     return cluster;
 }
 } /* switch_cluster */
@@ -2133,33 +2574,33 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         create_default_binding_cluster(endpoint);
     }
 
-    if(config != nullptr && check_feature_map(config->features)) {
-        if (config->features & feature::other::get_id()) {
+    if(config && check_feature_map(config->feature_flags)) {
+        if (config->feature_flags & feature::other::get_id()) {
             feature::other::add(cluster);
         }
-        if (config->features & feature::passive_infrared::get_id()) {
+        if (config->feature_flags & feature::passive_infrared::get_id()) {
             feature::passive_infrared::add(cluster);
         }
-        if (config->features & feature::ultrasonic::get_id()) {
+        if (config->feature_flags & feature::ultrasonic::get_id()) {
             feature::ultrasonic::add(cluster);
         }
-        if (config->features & feature::physical_contact::get_id()) {
+        if (config->feature_flags & feature::physical_contact::get_id()) {
             feature::physical_contact::add(cluster);
         }
-        if (config->features & feature::active_infrared::get_id()) {
+        if (config->feature_flags & feature::active_infrared::get_id()) {
             feature::active_infrared::add(cluster);
         }
-        if (config->features & feature::radar::get_id()) {
+        if (config->feature_flags & feature::radar::get_id()) {
             feature::radar::add(cluster);
         }
-        if (config->features & feature::rf_sensing::get_id()) {
+        if (config->feature_flags & feature::rf_sensing::get_id()) {
             feature::rf_sensing::add(cluster);
         }
-        if (config->features & feature::vision::get_id()) {
+        if (config->feature_flags & feature::vision::get_id()) {
             feature::vision::add(cluster);
         }
     } else {
-        ESP_LOGE(TAG, "Config is NULL or mandatory features are missing.");
+        ESP_LOGE(TAG, "Config is NULL or mandatory feature_flags are missing.");
     }
     return cluster;
 }
@@ -2229,17 +2670,19 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if (features & feature::visual::get_id()) {
-        feature::visual::add(cluster, &(config->visual));
-    }
-    if (features & feature::audible::get_id()) {
-        feature::audible::add(cluster, &(config->audible));
-    }
-    if (features & feature::alarm_suppress::get_id()) {
-        feature::alarm_suppress::add(cluster, &(config->alarm_suppress));
-    }
-    if (features & feature::sensitivity_level::get_id()) {
-        feature::sensitivity_level::add(cluster, &(config->sensitivity_level));
+    if(config) {
+        if (config->feature_flags & feature::visual::get_id()) {
+            feature::visual::add(cluster, &(config->features.visual));
+        }
+        if (config->feature_flags & feature::audible::get_id()) {
+            feature::audible::add(cluster, &(config->features.audible));
+        }
+        if (config->feature_flags & feature::alarm_suppress::get_id()) {
+            feature::alarm_suppress::add(cluster, &(config->features.alarm_suppress));
+        }
+        if (config->feature_flags & feature::sensitivity_level::get_id()) {
+            feature::sensitivity_level::add(cluster, &(config->features.sensitivity_level));
+        }
     }
     return cluster;
 }
@@ -2312,8 +2755,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if (features & feature::calendar_format::get_id()) {
-        feature::calendar_format::add(cluster, &(config->calendar_format));
+    if (config && config->feature_flags & feature::calendar_format::get_id()) {
+        feature::calendar_format::add(cluster, &(config->features.calendar_format));
     }
 
     return cluster;
@@ -2481,30 +2924,30 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         create_default_binding_cluster(endpoint);
     }
 
-    if(config != nullptr && check_feature_map(config->features)) {
-        if (config->features & feature::constant_pressure::get_id()) {
-            feature::constant_pressure::add(cluster, &config->constant_pressure);
+    if(config && check_feature_map(config->feature_flags)) {
+        if (config->feature_flags & feature::constant_pressure::get_id()) {
+            feature::constant_pressure::add(cluster, &config->features.constant_pressure);
         }
-        if (config->features & feature::compensated_pressure::get_id()) {
-            feature::compensated_pressure::add(cluster, &config->compensated_pressure);
+        if (config->feature_flags & feature::compensated_pressure::get_id()) {
+            feature::compensated_pressure::add(cluster, &config->features.compensated_pressure);
         }
-        if (config->features & feature::constant_flow::get_id()) {
-            feature::constant_flow::add(cluster, &config->constant_flow);
+        if (config->feature_flags & feature::constant_flow::get_id()) {
+            feature::constant_flow::add(cluster, &config->features.constant_flow);
         }
-        if (config->features & feature::constant_speed::get_id()) {
-            feature::constant_speed::add(cluster, &config->constant_speed);
+        if (config->feature_flags & feature::constant_speed::get_id()) {
+            feature::constant_speed::add(cluster, &config->features.constant_speed);
         }
-        if (config->features & feature::constant_temperature::get_id()) {
-            feature::constant_temperature::add(cluster, &config->constant_temperature);
+        if (config->feature_flags & feature::constant_temperature::get_id()) {
+            feature::constant_temperature::add(cluster, &config->features.constant_temperature);
         }
-        if (config->features & feature::automatic::get_id()) {
+        if (config->feature_flags & feature::automatic::get_id()) {
             feature::automatic::add(cluster);
         }
-        if (config->features & feature::local_operation::get_id()) {
+        if (config->feature_flags & feature::local_operation::get_id()) {
             feature::local_operation::add(cluster);
         }
     } else {
-        ESP_LOGE(TAG, "Config is NULL or mandatory features are missing.");
+        ESP_LOGE(TAG, "Config is NULL or mandatory feature_flags are missing.");
     }
     return cluster;
 }
@@ -2551,8 +2994,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     command::create_change_to_mode(cluster);
 
     /* Features */
-    if (features & feature::on_off::get_id()) {
-        feature::on_off::add(cluster, &(config->on_off));
+    if (config && config->feature_flags & feature::on_off::get_id()) {
+        feature::on_off::add(cluster, &(config->features.on_off));
     }
     return cluster;
 }
@@ -2611,7 +3054,7 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
         global::attribute::create_cluster_revision(cluster, cluster_revision);
     }
     /* Features */
-    if (features & feature::watermarks::get_id()) {
+    if (config && config->feature_flags & feature::watermarks::get_id()) {
         feature::watermarks::add(cluster);
     }
 
@@ -2644,14 +3087,16 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     command::create_set_temperature(cluster);
 
     /* Features */
-    if (features & feature::temperature_number::get_id()) {
-        feature::temperature_number::add(cluster, &(config->temperature_number));
-    }
-    if (features & feature::temperature_level::get_id()) {
-        feature::temperature_level::add(cluster, &(config->temperature_level));
-    }
-    if (features & feature::temperature_step::get_id()) {
-        feature::temperature_step::add(cluster, &(config->temperature_step));
+    if(config) {
+        if (config->feature_flags & feature::temperature_number::get_id()) {
+            feature::temperature_number::add(cluster, &(config->features.temperature_number));
+        }
+        if (config->feature_flags & feature::temperature_level::get_id()) {
+            feature::temperature_level::add(cluster, &(config->features.temperature_level));
+        }
+        if (config->feature_flags & feature::temperature_step::get_id()) {
+            feature::temperature_step::add(cluster, &(config->features.temperature_step));
+        }
     }
 
     return cluster;
@@ -2864,14 +3309,17 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     /* Commands */
     command::create_set_cooking_parameters(cluster);
 
-    if (features & feature::power_as_number::get_id()) {
-        feature::power_as_number::add(cluster);
-    }
-    if (features & feature::power_in_watts::get_id()) {
-        feature::power_in_watts::add(cluster);
-    }
-    if (features & feature::power_number_limits::get_id()) {
-        feature::power_number_limits::add(cluster);
+    /* Features */
+    if(config) {
+        if (config->feature_flags & feature::power_as_number::get_id()) {
+            feature::power_as_number::add(cluster);
+        }
+        if (config->feature_flags & feature::power_in_watts::get_id()) {
+            feature::power_in_watts::add(cluster);
+        }
+        if (config->feature_flags & feature::power_number_limits::get_id()) {
+            feature::power_number_limits::add(cluster);
+        }
     }
 
     return cluster;
@@ -2943,6 +3391,19 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
     command::create_send_key(cluster);
     command::create_send_key_response(cluster);
 
+    /* Features */
+    if(config) {
+        if(config->feature_flags & feature::navigation_key_codes::get_id()) {
+            feature::navigation_key_codes::add(cluster);
+        }
+        if(config->feature_flags & feature::location_keys::get_id()) {
+            feature::location_keys::add(cluster);
+        }
+        if(config->feature_flags & feature::number_keys::get_id()) {
+            feature::number_keys::add(cluster);
+        }
+    }
+
     return cluster;
 }
 } /* keypad_input */
@@ -2971,18 +3432,20 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if (features & feature::node_topology::get_id()) {
-        feature::node_topology::add(cluster);
-    }
-    else if (features & feature::tree_topology::get_id()) {
-            feature::tree_topology::add(cluster);
+    if(config) {
+        if (config->feature_flags & feature::node_topology::get_id()) {
+            feature::node_topology::add(cluster);
         }
-        else if (features & feature::set_topology::get_id()) {
-            feature::set_topology::add(cluster);
-            if (features & feature::dynamic_power_flow::get_id()) {
-                feature::dynamic_power_flow::add(cluster);
+        else if (config->feature_flags & feature::tree_topology::get_id()) {
+                feature::tree_topology::add(cluster);
             }
-        }
+            else if (config->feature_flags & feature::set_topology::get_id()) {
+                feature::set_topology::add(cluster);
+                if (config->feature_flags & feature::dynamic_power_flow::get_id()) {
+                    feature::dynamic_power_flow::add(cluster);
+                }
+            }
+    }
 
     return cluster;
 }
@@ -3016,28 +3479,30 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if((features & feature::direct_current::get_id()) || (features & feature::alternating_current::get_id())) {
-        if (features & feature::direct_current::get_id()) {
-            feature::direct_current::add(cluster);
+    if(config) {
+        if((config->feature_flags & feature::direct_current::get_id()) || (config->feature_flags & feature::alternating_current::get_id())) {
+            if (config->feature_flags & feature::direct_current::get_id()) {
+                feature::direct_current::add(cluster);
+            }
+            if (config->feature_flags & feature::alternating_current::get_id()) {
+                feature::alternating_current::add(cluster);
+
+                if (config->feature_flags & feature::polyphase_power::get_id()) {
+                    feature::polyphase_power::add(cluster);
+                }
+
+                if (config->feature_flags & feature::harmonics::get_id()) {
+                    feature::harmonics::add(cluster);
+                }
+
+                if (config->feature_flags & feature::power_quality::get_id()) {
+                    feature::power_quality::add(cluster);
+                }
+            }
+        } else {
+            ESP_LOGE(TAG, "At least one of the feature from Direct Current, Alternating Current shall be supported.");
+            return NULL;
         }
-        if (features & feature::alternating_current::get_id()) {
-            feature::alternating_current::add(cluster);
-
-            if (features & feature::polyphase_power::get_id()) {
-                feature::polyphase_power::add(cluster);
-            }
-
-            if (features & feature::harmonics::get_id()) {
-                feature::harmonics::add(cluster);
-            }
-
-            if (features & feature::power_quality::get_id()) {
-                feature::power_quality::add(cluster);
-            }
-        }
-    } else {
-        ESP_LOGE(TAG, "At least one of the feature from Direct Current, Alternating Current shall be supported.");
-        return NULL;
     }
 
     return cluster;
@@ -3065,28 +3530,30 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if((features & feature::imported_energy::get_id()) || (features & feature::exported_energy::get_id())) {
-        if (features & feature::imported_energy::get_id()) {
-            feature::imported_energy::add(cluster);
+    if(config) {
+        if((config->feature_flags & feature::imported_energy::get_id()) || (config->feature_flags & feature::exported_energy::get_id())) {
+            if (config->feature_flags & feature::imported_energy::get_id()) {
+                feature::imported_energy::add(cluster);
+            }
+            if (config->feature_flags & feature::exported_energy::get_id()) {
+                feature::exported_energy::add(cluster);
+            }
+        } else {
+            ESP_LOGE(TAG, "At least one of the feature from Imported Energy, Exported Energy shall be supported.");
+            return NULL;
         }
-        if (features & feature::exported_energy::get_id()) {
-            feature::exported_energy::add(cluster);
-        }
-    } else {
-        ESP_LOGE(TAG, "At least one of the feature from Imported Energy, Exported Energy shall be supported.");
-        return NULL;
-    }
 
-    if((features & feature::cumulative_energy::get_id()) || (features & feature::periodic_energy::get_id())) {
-        if (features & feature::cumulative_energy::get_id()) {
-            feature::cumulative_energy::add(cluster);
+        if((config->feature_flags & feature::cumulative_energy::get_id()) || (config->feature_flags & feature::periodic_energy::get_id())) {
+            if (config->feature_flags & feature::cumulative_energy::get_id()) {
+                feature::cumulative_energy::add(cluster);
+            }
+            if (config->feature_flags & feature::periodic_energy::get_id()) {
+                feature::periodic_energy::add(cluster);
+            }
+        } else {
+            ESP_LOGE(TAG, "At least one of the feature from Cumulative Energy, Periodic Energy shall be supported.");
+            return NULL;
         }
-        if (features & feature::periodic_energy::get_id()) {
-            feature::periodic_energy::add(cluster);
-        }
-    } else {
-        ESP_LOGE(TAG, "At least one of the feature from Cumulative Energy, Periodic Energy shall be supported.");
-        return NULL;
     }
 
     return cluster;
@@ -3164,20 +3631,22 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if (features & feature::charging_preferences::get_id()) {
-        feature::charging_preferences::add(cluster);
-    }
-    if (features & feature::soc_reporting::get_id()) {
-        feature::soc_reporting::add(cluster);
-    }
-    if (features & feature::plug_and_charge::get_id()) {
-        feature::plug_and_charge::add(cluster);
-    }
-    if (features & feature::rfid::get_id()) {
-        feature::rfid::add(cluster);
-    }
-    if (features & feature::v2x::get_id()) {
-        feature::v2x::add(cluster);
+    if(config) {
+        if (config->feature_flags & feature::charging_preferences::get_id()) {
+            feature::charging_preferences::add(cluster);
+        }
+        if (config->feature_flags & feature::soc_reporting::get_id()) {
+            feature::soc_reporting::add(cluster);
+        }
+        if (config->feature_flags & feature::plug_and_charge::get_id()) {
+            feature::plug_and_charge::add(cluster);
+        }
+        if (config->feature_flags & feature::rfid::get_id()) {
+            feature::rfid::add(cluster);
+        }
+        if (config->feature_flags & feature::v2x::get_id()) {
+            feature::v2x::add(cluster);
+        }
     }
 
     /* Commands */
@@ -3230,11 +3699,13 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     command::create_close(cluster);
 
     /* Features */
-    if (features & feature::time_sync::get_id()) {
-        feature::time_sync::add(cluster, &(config->time_sync));
-    }
-    if (features & feature::level::get_id()) {
-        feature::level::add(cluster, &(config->level));
+    if(config) {
+        if (config->feature_flags & feature::time_sync::get_id()) {
+            feature::time_sync::add(cluster, &(config->features.time_sync));
+        }
+        if (config->feature_flags & feature::level::get_id()) {
+            feature::level::add(cluster, &(config->features.level));
+        }
     }
 
     return cluster;
@@ -3276,31 +3747,37 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if (features & feature::power_adjustment::get_id()) {
-        feature::power_adjustment::add(cluster);
-    }
-    if (features & feature::power_forecast_reporting::get_id()) {
-        feature::power_forecast_reporting::add(cluster);
-    }
-    if (features & feature::state_forecast_reporting::get_id()) {
-        if ((!(features & feature::power_adjustment::get_id()) ||
-            (features & feature::start_time_adjustment::get_id()) ||
-            (features & feature::pausable::get_id()) ||
-            (features & feature::forecast_adjustment::get_id()) ||
-            (features & feature::constraint_based_adjustment::get_id())) &&
-            !(features & feature::power_forecast_reporting::get_id())) {
-
-            feature::state_forecast_reporting::add(cluster);
+    if(config) {
+        if (config->feature_flags & feature::power_adjustment::get_id()) {
+            feature::power_adjustment::add(cluster);
+        }
+        if (config->feature_flags & feature::power_forecast_reporting::get_id()) {
+            if ((!(config->feature_flags & feature::power_adjustment::get_id()) ||
+                (config->feature_flags & feature::start_time_adjustment::get_id()) ||
+                (config->feature_flags & feature::pausable::get_id()) ||
+                (config->feature_flags & feature::forecast_adjustment::get_id()) ||
+                (config->feature_flags & feature::constraint_based_adjustment::get_id()))) {
+
+                feature::power_forecast_reporting::add(cluster);
+            }
+        }
+        else if (config->feature_flags & feature::state_forecast_reporting::get_id()) {
+            if (!(config->feature_flags & feature::power_adjustment::get_id())) {
+                feature::state_forecast_reporting::add(cluster);
+            }
+        }
+        if (config->feature_flags & feature::pausable::get_id()) {
+            feature::pausable::add(cluster);
+        }
+        if (config->feature_flags & feature::start_time_adjustment::get_id()) {
+            feature::start_time_adjustment::add(cluster);
+        }
+        if (config->feature_flags & feature::forecast_adjustment::get_id()) {
+            feature::forecast_adjustment::add(cluster);
+        }
+        if (config->feature_flags & feature::constraint_based_adjustment::get_id()) {
+            feature::constraint_based_adjustment::add(cluster);
         }
-    }
-    if (features & feature::pausable::get_id()) {
-        feature::pausable::add(cluster);
-    }
-    if (features & feature::forecast_adjustment::get_id()) {
-        feature::forecast_adjustment::add(cluster);
-    }
-    if (features & feature::constraint_based_adjustment::get_id()) {
-        feature::constraint_based_adjustment::add(cluster);
     }
     return cluster;
 }
@@ -3417,7 +3894,7 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     command::create_dataset_response(cluster);
     command::create_set_active_dataset_request(cluster);
 
-    if (features & feature::pan_change::get_id()) {
+    if (config && config->feature_flags & feature::pan_change::get_id()) {
         feature::pan_change::add(cluster);
     }
 
@@ -3525,14 +4002,16 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
         global::attribute::create_cluster_revision(cluster, cluster_revision);
     }
 
-    if (features & feature::select_while_running::get_id()) {
-        feature::select_while_running::add(cluster);
-    }
-    if (features & feature::progress_reporting::get_id()) {
-        feature::progress_reporting::add(cluster);
-    }
-    if (features & feature::maps::get_id()) {
-        feature::maps::add(cluster);
+    if(config) {
+        if (config->feature_flags & feature::select_while_running::get_id()) {
+            feature::select_while_running::add(cluster);
+        }
+        if (config->feature_flags & feature::progress_reporting::get_id()) {
+            feature::progress_reporting::add(cluster);
+        }
+        if (config->feature_flags & feature::maps::get_id()) {
+            feature::maps::add(cluster);
+        }
     }
 
     /* Commands */
@@ -3573,11 +4052,13 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
         attribute::create_boost_state(cluster, config->boost_state);
     }
 
-    if (features & feature::energy_management::get_id()) {
-        feature::energy_management::add(cluster, &(config->energy_management));
-    }
-    if (features & feature::tank_percent::get_id()) {
-        feature::tank_percent::add(cluster, &(config->tank_percent));
+    if(config) {
+        if (config->feature_flags & feature::energy_management::get_id()) {
+            feature::energy_management::add(cluster, &(config->features.energy_management));
+        }
+        if (config->feature_flags & feature::tank_percent::get_id()) {
+            feature::tank_percent::add(cluster, &(config->features.tank_percent));
+        }
     }
 
     /* Commands */
@@ -3663,11 +4144,13 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
     }
 
     /* Features */
-    if (features & feature::energy_balance::get_id()) {
-        feature::energy_balance::add(cluster, &(config->energy_balance));
-    }
-    if (features & feature::low_power_mode_sensitivity::get_id()) {
-        feature::low_power_mode_sensitivity::add(cluster, &(config->low_power_mode_sensitivity));
+    if(config) {
+        if (config->feature_flags & feature::energy_balance::get_id()) {
+            feature::energy_balance::add(cluster, &(config->features.energy_balance));
+        }
+        if (config->feature_flags & feature::low_power_mode_sensitivity::get_id()) {
+            feature::low_power_mode_sensitivity::add(cluster, &(config->features.low_power_mode_sensitivity));
+        }
     }
 
     return cluster;
diff --git a/components/esp_matter/esp_matter_cluster.h b/components/esp_matter/esp_matter_cluster.h
index 2307ac1a9..fb6e681c2 100644
--- a/components/esp_matter/esp_matter_cluster.h
+++ b/components/esp_matter/esp_matter_cluster.h
@@ -56,6 +56,12 @@ void add_bounds_callback_common();
  * If a custom cluster needs to be created, the low level esp_matter::cluster::create() API can be used.
  */
 
+/** Note: Some features might appear to be missing in the cluster configuration because a feature configuration is
+ * only created if there are mandatory attributes managed by Esp-Matter. Since these features do not have any mandatory
+ * attributes, they have not been added to the cluster configuration.
+ * To create such features, you can directly pass their feature IDs in the features_flag of the cluster configuration.
+ */
+
 namespace common {
 
 typedef struct config {
@@ -66,8 +72,8 @@ typedef struct config {
 
 namespace descriptor {
 typedef struct config {
-    uint32_t features;
-    config() : features(0) {}
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
 } config_t;
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* descriptor */
@@ -78,7 +84,10 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* actions */
 
 namespace access_control {
-using config_t = common::config_t;
+typedef struct config {
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
+} config_t;
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* access_control */
 
@@ -115,7 +124,11 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace general_commissioning {
 typedef struct config {
     uint64_t breadcrumb;
-    config() : breadcrumb(0) {}
+    struct {
+        feature::terms_and_conditions::config_t terms_and_conditions;
+    } features;
+    uint32_t feature_flags;
+    config() : breadcrumb(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -147,12 +160,21 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* general_diagnostics */
 
 namespace software_diagnostics {
-using config_t = common::config_t;
+typedef struct config {
+    uint32_t feature_flags;
+    struct {
+        feature::watermarks::config_t watermarks;
+    } features;
+    config() : feature_flags(0) {}
+} config_t;
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
 } /* software_diagnostics */
 
 namespace administrator_commissioning {
-using config_t = common::config_t;
+typedef struct config {
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
+} config_t;
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
 } /* administrator_commissioning */
 
@@ -167,7 +189,10 @@ cluster_t *create(endpoint_t *endpoint, uint8_t flags);
 } /* group_key_management */
 
 namespace wifi_network_diagnostics {
-using config_t = common::config_t;
+typedef struct config {
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
+} config_t;
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* wifi_network_diagnostics */
 
@@ -177,14 +202,27 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* thread_network_diagnostics */
 
 namespace ethernet_network_diagnostics {
-using config_t = common::config_t;
+typedef struct config {
+    struct {
+        feature::packet_counts::config_t packet_counts;
+        feature::error_counts::config_t error_counts;
+    } features;
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
+} config_t;
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* ethernet_network_diagnostics */
 
 namespace time_synchronization {
 typedef struct config {
+    struct {
+        feature::time_zone::config_t time_zone;
+        feature::ntp_client::config_t ntp_client;
+        feature::ntp_server::config_t ntp_server;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -192,8 +230,11 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace unit_localization {
 typedef struct config {
-    feature::temperature_unit::config_t temperature_unit;
-    // Empty config for API consistency
+    struct {
+        feature::temperature_unit::config_t temperature_unit;
+    } features;
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -202,7 +243,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
 namespace bridged_device_basic_information {
 typedef struct config {
     bool reachable;
-    config() : reachable(true) {}
+    uint32_t feature_flags;
+    config() : reachable(true), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -213,11 +255,14 @@ typedef struct config {
     uint8_t status;
     uint8_t order;
     char description[k_max_description_length + 1];
-    feature::wired::config_t wired;
-    feature::battery::config_t battery;
-    feature::rechargeable::config_t rechargeable;
-    feature::replaceable::config_t replaceable;
-	config() : status(0), order(0), description{0} {}
+    struct {
+        feature::wired::config_t wired;
+        feature::battery::config_t battery;
+        feature::rechargeable::config_t rechargeable;
+        feature::replaceable::config_t replaceable;
+    } features;
+    uint32_t feature_flags;
+	config() : status(0), order(0), description{0}, feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -225,8 +270,11 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
 
 namespace icd_management {
 typedef struct config {
-    feature::user_active_mode_trigger::config_t user_active_mode_trigger;
-    // Empty config for API consistency
+    struct {
+        feature::user_active_mode_trigger::config_t user_active_mode_trigger;
+    } features;
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -261,7 +309,8 @@ uint8_t get_server_cluster_count();
 namespace scenes_management {
 typedef struct config {
     uint16_t scene_table_size;
-    config() : scene_table_size(16) {}
+    uint32_t feature_flags;
+    config() : scene_table_size(16), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -270,8 +319,11 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace on_off {
 typedef struct config {
     bool on_off;
-    feature::lighting::config_t lighting;
-    config() : on_off(false) {}
+    struct {
+        feature::lighting::config_t lighting;
+    } features;
+    uint32_t feature_flags;
+    config() : on_off(false), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -282,8 +334,12 @@ typedef struct config {
     nullable<uint8_t> current_level;
     nullable<uint8_t> on_level;
     uint8_t options;
-    feature::lighting::config_t lighting;
-    config() : current_level(), on_level(), options(0) {}
+    struct {
+        feature::lighting::config_t lighting;
+        feature::frequency::config_t frequency;
+    } features;
+    uint32_t feature_flags;
+    config() : current_level(), on_level(), options(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -296,13 +352,16 @@ typedef struct config {
     uint8_t enhanced_color_mode;
     uint16_t color_capabilities;
     nullable<uint8_t> number_of_primaries;
-    feature::hue_saturation::config_t hue_saturation;
-    feature::color_temperature::config_t color_temperature;
-    feature::xy::config_t xy;
-    feature::enhanced_hue::config_t enhanced_hue;
-    feature::color_loop::config_t color_loop;
+    struct {
+        feature::hue_saturation::config_t hue_saturation;
+        feature::color_temperature::config_t color_temperature;
+        feature::xy::config_t xy;
+        feature::enhanced_hue::config_t enhanced_hue;
+        feature::color_loop::config_t color_loop;
+    } features;
+    uint32_t feature_flags;
     config() : color_mode(1), color_control_options(0), enhanced_color_mode(1),
-               color_capabilities(0), number_of_primaries(0) {}
+               color_capabilities(0), number_of_primaries(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -314,8 +373,15 @@ typedef struct config {
     uint8_t fan_mode_sequence;
     nullable<uint8_t> percent_setting;
     uint8_t percent_current;
+    struct {
+        feature::multi_speed::config_t multi_speed;
+        feature::rocking::config_t rocking;
+        feature::wind::config_t wind;
+        feature::airflow_direction::config_t airflow_direction;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : fan_mode(0), fan_mode_sequence(2), percent_setting(0), percent_current(0), delegate(nullptr) {}
+    config() : fan_mode(0), fan_mode_sequence(2), percent_setting(0), percent_current(0), feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -326,14 +392,17 @@ typedef struct config {
     nullable<int16_t> local_temperature;
     uint8_t control_sequence_of_operation;
     uint8_t system_mode;
-    feature::heating::config_t heating;
-    feature::cooling::config_t cooling;
-    feature::occupancy::config_t occupancy;
-    feature::setback::config_t setback;
-    feature::schedule_configuration::config_t schedule_configuration;
-    feature::auto_mode::config_t auto_mode;
-    feature::local_temperature_not_exposed::config_t local_temperature_not_exposed;
-    config() : local_temperature(), control_sequence_of_operation(4), system_mode(1) {}
+    struct {
+        feature::heating::config_t heating;
+        feature::cooling::config_t cooling;
+        feature::occupancy::config_t occupancy;
+        feature::setback::config_t setback;
+        feature::auto_mode::config_t auto_mode;
+        feature::local_temperature_not_exposed::config_t local_temperature_not_exposed;
+        feature::matter_schedule_configuration::config_t matter_schedule_configuration;
+    } features;
+    uint32_t feature_flags;
+    config() : local_temperature(), control_sequence_of_operation(4), system_mode(1), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -350,14 +419,22 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* thermostat_user_interface_configuration */
 
 namespace air_quality {
-using config_t = common::config_t;
+typedef struct config {
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
+} config_t;
+
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* air_quality */
 
 namespace hepa_filter_monitoring {
 typedef struct config {
+    struct {
+        feature::condition::config_t condition;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -365,8 +442,12 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace activated_carbon_filter_monitoring {
 typedef struct config {
+    struct {
+        feature::condition::config_t condition;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -375,7 +456,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace carbon_monoxide_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -384,7 +472,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace carbon_dioxide_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -393,7 +488,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace nitrogen_dioxide_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -402,7 +504,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace ozone_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -411,7 +520,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace formaldehyde_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -420,7 +536,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace pm1_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -429,7 +552,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace pm25_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -438,7 +568,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace pm10_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -447,7 +584,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace radon_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -456,7 +600,14 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace total_volatile_organic_compounds_concentration_measurement {
 typedef struct config {
     uint8_t measurement_medium;
-    config() : measurement_medium(0) {}
+    struct {
+        feature::numeric_measurement::config_t numeric_measurement;
+        feature::level_indication::config_t level_indication;
+        feature::peak_measurement::config_t peak_measurement;
+        feature::average_measurement::config_t average_measurement;
+    } features;
+    uint32_t feature_flags;
+    config() : measurement_medium(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -483,10 +634,13 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace laundry_washer_controls {
 typedef struct config {
-    feature::spin::config_t spin;
-    feature::rinse::config_t rinse;
+    struct {
+        feature::spin::config_t spin;
+        feature::rinse::config_t rinse;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -522,7 +676,11 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* dish_washer_alarm */
 
 namespace smoke_co_alarm {
-using config_t = common::config_t;
+typedef struct config {
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
+} config_t;
+
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* smoke_co_alarm */
 
@@ -533,8 +691,15 @@ typedef struct config {
     bool actuator_enabled;
     uint8_t operating_mode;
     uint16_t supported_operating_modes;
+    struct {
+        feature::pin_credential::config_t pin_credential;
+        feature::rfid_credential::config_t rfid_credential;
+        feature::credential_over_the_air_access::config_t credential_over_the_air_access;
+        feature::user::config_t user;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : lock_state(0), lock_type(0), actuator_enabled(0), operating_mode(0), supported_operating_modes(0xFFF6), delegate(nullptr) {}
+    config() : lock_state(0), lock_type(0), actuator_enabled(0), operating_mode(0), supported_operating_modes(0xFFF6), feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -547,9 +712,16 @@ typedef struct config {
     uint8_t operational_status;
     const uint8_t end_product_type;
     uint8_t mode;
-    feature::lift::config_t lift;
+    struct {
+        feature::lift::config_t lift;
+        feature::tilt::config_t tilt;
+        feature::position_aware_lift::config_t position_aware_lift;
+        feature::absolute_position::config_t absolute_position;
+        feature::position_aware_tilt::config_t position_aware_tilt;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config(uint8_t end_product_type = 0) : type(0), config_status(0), operational_status(0), end_product_type(end_product_type), mode(0), delegate(nullptr) {}
+    config(uint8_t end_product_type = 0) : type(0), config_status(0), operational_status(0), end_product_type(end_product_type), mode(0), feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -559,7 +731,11 @@ namespace switch_cluster {
 typedef struct config {
     uint8_t number_of_positions;
     uint8_t current_position;
-    config() : number_of_positions(2), current_position(0) {}
+    struct {
+        feature::momentary_switch_multi_press::config_t momentary_switch_multi_press;
+    } features;
+    uint32_t feature_flags;
+    config() : number_of_positions(2), current_position(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -592,9 +768,9 @@ typedef struct config {
     uint8_t occupancy;
     uint8_t occupancy_sensor_type;
     uint8_t occupancy_sensor_type_bitmap;
-    uint32_t features;
+    uint32_t feature_flags;
     config() : occupancy(0), occupancy_sensor_type(0),
-               occupancy_sensor_type_bitmap(0), features(0) {}
+               occupancy_sensor_type_bitmap(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -611,12 +787,15 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace boolean_state_configuration {
 typedef struct config {
-    feature::visual::config_t visual;
-    feature::audible::config_t audible;
-    feature::alarm_suppress::config_t alarm_suppress;
-    feature::sensitivity_level::config_t sensitivity_level;
+    struct {
+        feature::visual::config_t visual;
+        feature::audible::config_t audible;
+        feature::alarm_suppress::config_t alarm_suppress;
+        feature::sensitivity_level::config_t sensitivity_level;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -634,8 +813,11 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 namespace time_format_localization {
 typedef struct config {
     uint8_t hour_format;
-    feature::calendar_format::config_t calendar_format;
-    config() : hour_format(0) {}
+    struct {
+        feature::calendar_format::config_t calendar_format;
+    } features;
+    uint32_t feature_flags;
+    config() : hour_format(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -686,18 +868,20 @@ typedef struct config {
     nullable<int16_t> capacity;
     // Pump Settings Attributes
     uint8_t operation_mode;
-    feature::constant_pressure::config_t constant_pressure;
-    feature::compensated_pressure::config_t compensated_pressure;
-    feature::constant_flow::config_t constant_flow;
-    feature::constant_speed::config_t constant_speed;
-    feature::constant_temperature::config_t constant_temperature;
-    uint32_t features;
+    struct {
+        feature::constant_pressure::config_t constant_pressure;
+        feature::compensated_pressure::config_t compensated_pressure;
+        feature::constant_flow::config_t constant_flow;
+        feature::constant_speed::config_t constant_speed;
+        feature::constant_temperature::config_t constant_temperature;
+    } features;
+    uint32_t feature_flags;
     config(
         nullable<int16_t> max_pressure = nullable<int16_t>(),
         nullable<uint16_t> max_speed = nullable<uint16_t>(),
         nullable<uint16_t> max_flow = nullable<uint16_t>()
     ) : max_pressure(max_pressure), max_speed(max_speed), max_flow(max_flow),
-        effective_operation_mode(0), effective_control_mode(0), capacity(), operation_mode(0), features(0) {}
+        effective_operation_mode(0), effective_control_mode(0), capacity(), operation_mode(0), feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -708,9 +892,12 @@ typedef struct config {
     char mode_select_description[k_max_mode_select_description_length + 1];
     const nullable<uint16_t> standard_namespace;
     uint8_t current_mode;
-    feature::on_off::config_t on_off;
+    struct {
+        feature::on_off::config_t on_off;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : mode_select_description{0}, standard_namespace(), current_mode(0), delegate(nullptr) {}
+    config() : mode_select_description{0}, standard_namespace(), current_mode(0), feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -718,11 +905,13 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
 
 namespace temperature_control {
 typedef struct config {
-    feature::temperature_number::config_t temperature_number;
-    feature::temperature_level::config_t temperature_level;
-    feature::temperature_step::config_t temperature_step;
-    uint32_t features;
-    config() : features(0) {}
+    struct {
+        feature::temperature_number::config_t temperature_number;
+        feature::temperature_level::config_t temperature_level;
+        feature::temperature_step::config_t temperature_step;
+    } features;
+    uint32_t feature_flags;
+    config() : feature_flags(0) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -781,8 +970,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace microwave_oven_control {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -795,8 +985,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace keypad_input {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -804,8 +995,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace power_topology {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -813,8 +1005,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
 
 namespace electrical_power_measurement {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -822,8 +1015,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
 
 namespace electrical_energy_measurement {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -841,8 +1035,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace energy_evse {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -854,10 +1049,13 @@ typedef struct config {
     nullable<uint32_t> default_open_duration;
     nullable<uint8_t> current_state;
     nullable<uint8_t> target_state;
-    feature::time_sync::config_t time_sync;
-    feature::level::config_t level;
+    struct {
+        feature::time_sync::config_t time_sync;
+        feature::level::config_t level;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : open_duration(), default_open_duration(), current_state(), target_state(), delegate(nullptr) {}
+    config() : open_duration(), default_open_duration(), current_state(), target_state(), feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -865,8 +1063,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_
 
 namespace device_energy_management {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -893,8 +1092,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace thread_border_router_management {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -912,8 +1112,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace service_area {
 typedef struct config {
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -924,10 +1125,13 @@ typedef struct config {
     uint8_t heater_types;
     uint8_t heat_demand;
     uint8_t boost_state;
+    struct {
+        feature::energy_management::config_t energy_management;
+        feature::tank_percent::config_t tank_percent;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    feature::energy_management::config_t energy_management;
-    feature::tank_percent::config_t tank_percent;
-    config() : heater_types(0), heat_demand(0), boost_state(0), delegate(nullptr) {}
+    config() : heater_types(0), heat_demand(0), boost_state(0), feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
@@ -945,10 +1149,13 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 
 namespace energy_preference {
 typedef struct config {
-    feature::energy_balance::config_t energy_balance;
-    feature::low_power_mode_sensitivity::config_t low_power_mode_sensitivity;
+    struct {
+        feature::energy_balance::config_t energy_balance;
+        feature::low_power_mode_sensitivity::config_t low_power_mode_sensitivity;
+    } features;
+    uint32_t feature_flags;
     void *delegate;
-    config() : delegate(nullptr) {}
+    config() : feature_flags(0), delegate(nullptr) {}
 } config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
diff --git a/components/esp_matter/esp_matter_command.cpp b/components/esp_matter/esp_matter_command.cpp
index 788d2e32f..4f29bbd20 100644
--- a/components/esp_matter/esp_matter_command.cpp
+++ b/components/esp_matter/esp_matter_command.cpp
@@ -1580,7 +1580,12 @@ namespace command {
 command_t *create_review_fabric_restrictions(cluster_t *cluster)
 {
     return esp_matter::command::create(cluster, AccessControl::Commands::ReviewFabricRestrictions::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_review_fabric_restrictions);
+#if CHIP_CONFIG_USE_ACCESS_RESTRICTIONS
+                                       esp_matter_command_callback_review_fabric_restrictions
+#else
+                                       NULL
+#endif
+    );
 }
 
 command_t *create_review_fabric_restrictions_response(cluster_t *cluster)
@@ -1596,7 +1601,8 @@ namespace command {
 command_t *create_keep_active(cluster_t *cluster)
 {
     return esp_matter::command::create(cluster, BridgedDeviceBasicInformation::Commands::KeepActive::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_keep_active);
+    // Command callback not implemented in connectedhomeip.
+                                       NULL);
 }
 
 } /* command */
@@ -2357,7 +2363,8 @@ command_t *create_stop_with_on_off(cluster_t *cluster)
 command_t *create_move_to_closest_frequency(cluster_t *cluster)
 {
     return esp_matter::command::create(cluster, LevelControl::Commands::MoveToClosestFrequency::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_move_to_closest_frequency);
+    // Command callback not implemented in connectedhomeip.
+                                       NULL);
 }
 
 } /* command */
diff --git a/components/esp_matter/esp_matter_endpoint.cpp b/components/esp_matter/esp_matter_endpoint.cpp
index ffa05f7bd..6643cf1f0 100644
--- a/components/esp_matter/esp_matter_endpoint.cpp
+++ b/components/esp_matter/esp_matter_endpoint.cpp
@@ -1895,9 +1895,9 @@ esp_err_t add(endpoint_t *endpoint, config_t *config)
     descriptor::feature::taglist::add(descriptor_cluster);
 
     power_source_device::add(endpoint, &config->power_source_device);
-
-    cluster_t *power_source_cluster = cluster::get(endpoint, PowerSource::Id);
-    power_source::feature::wired::add(power_source_cluster, &config->power_source_device.power_source.wired);
+        
+    cluster_t *power_source_cluster = cluster::get(endpoint, PowerSource::Id); 
+    power_source::feature::wired::add(power_source_cluster, &config->power_source_device.power_source.features.wired);
     electrical_sensor::add(endpoint, &config->electrical_sensor);
     electrical_energy_measurement::create(endpoint, &(config->electrical_energy_measurement), CLUSTER_FLAG_SERVER, electrical_energy_measurement::feature::exported_energy::get_id() | electrical_energy_measurement::feature::cumulative_energy::get_id());
 
@@ -1937,10 +1937,10 @@ esp_err_t add(endpoint_t *endpoint, config_t *config)
     descriptor::feature::taglist::add(descriptor_cluster);
 
     power_source_device::add(endpoint, &config->power_source_device);
-
-    cluster_t *power_source_cluster = cluster::get(endpoint, PowerSource::Id);
-    power_source::feature::wired::add(power_source_cluster, &config->power_source_device.power_source.wired);
-    power_source::feature::battery::add(power_source_cluster, &config->power_source_device.power_source.battery);
+        
+    cluster_t *power_source_cluster = cluster::get(endpoint, PowerSource::Id); 
+    power_source::feature::wired::add(power_source_cluster, &config->power_source_device.power_source.features.wired);
+    power_source::feature::battery::add(power_source_cluster, &config->power_source_device.power_source.features.battery);
 
     power_source::attribute::create_bat_voltage(power_source_cluster, config->bat_voltage, 0x00, 0xFFFF);
     power_source::attribute::create_bat_percent_remaining(power_source_cluster, config->bat_percent_remaining, 0, 200);
@@ -1992,9 +1992,9 @@ esp_err_t add(endpoint_t *endpoint, config_t *config)
     descriptor::feature::taglist::add(descriptor_cluster);
 
     power_source_device::add(endpoint, &config->power_source_device);
-
-    cluster_t *power_source_cluster = cluster::get(endpoint, PowerSource::Id);
-    power_source::feature::wired::add(power_source_cluster, &config->power_source_device.power_source.wired);
+        
+    cluster_t *power_source_cluster = cluster::get(endpoint, PowerSource::Id); 
+    power_source::feature::wired::add(power_source_cluster, &config->power_source_device.power_source.features.wired);
 
     electrical_sensor::add(endpoint, &config->electrical_sensor);
 
diff --git a/components/esp_matter/esp_matter_feature.cpp b/components/esp_matter/esp_matter_feature.cpp
index 250cc23b7..9ce0d7da0 100644
--- a/components/esp_matter/esp_matter_feature.cpp
+++ b/components/esp_matter/esp_matter_feature.cpp
@@ -925,7 +925,7 @@ esp_err_t add(cluster_t *cluster, config_t *config)
 namespace wifi_network_diagnostics {
 namespace feature {
 
-namespace packets_counts {
+namespace packet_counts {
 
 uint32_t get_id()
 {
@@ -949,7 +949,7 @@ esp_err_t add(cluster_t *cluster)
     return ESP_OK;
 }
 
-} /* packets_counts */
+} /* packet_counts */
 
 namespace error_counts {
 
@@ -1059,7 +1059,7 @@ esp_err_t add(cluster_t *cluster)
 namespace ethernet_network_diagnostics {
 namespace feature {
 
-namespace packets_counts {
+namespace packet_counts {
 
 uint32_t get_id()
 {
@@ -1078,7 +1078,7 @@ esp_err_t add(cluster_t *cluster, config_t *config)
     return ESP_OK;
 }
 
-} /* packets_counts */
+} /* packet_counts */
 
 namespace error_counts {
 
@@ -2698,31 +2698,6 @@ esp_err_t add(cluster_t *cluster, config_t *config)
 }
 } /* occupancy */
 
-namespace schedule_configuration {
-
-uint32_t get_id()
-{
-    return (uint32_t)Thermostat::Feature::kScheduleConfiguration;
-}
-
-esp_err_t add(cluster_t *cluster, config_t *config)
-{
-    VerifyOrReturnError(cluster, ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Cluster cannot be NULL"));
-    update_feature_map(cluster, get_id());
-
-    attribute::create_start_of_week(cluster, config->start_of_week);
-    attribute::create_number_of_weekly_transitions(cluster, config->number_of_weekly_transitions);
-    attribute::create_number_of_daily_transitions(cluster, config->number_of_daily_transitions);
-
-    command::create_set_weekly_schedule(cluster);
-    command::create_get_weekly_schedule(cluster);
-    command::create_clear_weekly_schedule(cluster);
-    command::create_get_weekly_schedule_response(cluster);
-
-    return ESP_OK;
-}
-} /* schedule_configuration */
-
 namespace setback {
 
 uint32_t get_id()
@@ -2811,7 +2786,7 @@ uint32_t get_id()
     return (uint32_t)Thermostat::Feature::kPresets;
 }
 
-esp_err_t add(cluster_t *cluster, config_t *config)
+esp_err_t add(cluster_t *cluster)
 {
     if (!cluster) {
         ESP_LOGE(TAG, "Cluster cannot be NULL");
@@ -2820,7 +2795,7 @@ esp_err_t add(cluster_t *cluster, config_t *config)
     update_feature_map(cluster, get_id());
 
     /* Attributes managed internally */
-    attribute::create_preset_type(cluster, NULL, 0, 0);
+    attribute::create_preset_types(cluster, NULL, 0, 0);
     attribute::create_number_of_presets(cluster, 0);
     attribute::create_active_preset_handle(cluster, NULL, 0);
     attribute::create_presets(cluster, NULL, 0, 0);
@@ -3834,7 +3809,7 @@ uint32_t get_id()
     return (uint32_t)DoorLock::Feature::kWeekDayAccessSchedules;
 }
 
-esp_err_t add(cluster_t *cluster, config_t *config)
+esp_err_t add(cluster_t *cluster)
 {
     VerifyOrReturnError(cluster, ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Cluster cannot be NULL"));
     update_feature_map(cluster, get_id());
@@ -3986,7 +3961,7 @@ uint32_t get_id()
     return (uint32_t)DoorLock::Feature::kYearDayAccessSchedules;
 }
 
-esp_err_t add(cluster_t *cluster, config_t *config)
+esp_err_t add(cluster_t *cluster)
 {
     VerifyOrReturnError(cluster, ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Cluster cannot be NULL"));
     update_feature_map(cluster, get_id());
@@ -4012,7 +3987,7 @@ uint32_t get_id()
     return (uint32_t)DoorLock::Feature::kHolidaySchedules;
 }
 
-esp_err_t add(cluster_t *cluster, config_t *config)
+esp_err_t add(cluster_t *cluster)
 {
     VerifyOrReturnError(cluster, ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Cluster cannot be NULL"));
     update_feature_map(cluster, get_id());
diff --git a/components/esp_matter/esp_matter_feature.h b/components/esp_matter/esp_matter_feature.h
index 9d390852e..6fd2ff6bf 100644
--- a/components/esp_matter/esp_matter_feature.h
+++ b/components/esp_matter/esp_matter_feature.h
@@ -471,12 +471,12 @@ esp_err_t add(cluster_t *cluster, config_t *config);
 namespace wifi_network_diagnostics {
 namespace feature {
 
-namespace packets_counts {
+namespace packet_counts {
 
 uint32_t get_id();
 esp_err_t add(cluster_t *cluster);
 
-} /* packets_counts */
+} /* packet_counts */
 
 namespace error_counts {
 
@@ -525,7 +525,7 @@ esp_err_t add(cluster_t *cluster);
 namespace ethernet_network_diagnostics {
 namespace feature {
 
-namespace packets_counts {
+namespace packet_counts {
 
 typedef struct config {
     uint64_t packet_rx_count;
@@ -536,7 +536,7 @@ typedef struct config {
 uint32_t get_id();
 esp_err_t add(cluster_t *cluster, config_t *config);
 
-} /* packets_counts */
+} /* packet_counts */
 
 namespace error_counts {
 
@@ -601,20 +601,6 @@ uint32_t get_id();
 esp_err_t add(cluster_t *cluster, config_t *config);
 } /* occupancy */
 
-namespace schedule_configuration {
-
-typedef struct config {
-   uint8_t start_of_week;
-   uint8_t number_of_weekly_transitions;
-   uint8_t number_of_daily_transitions;
-
-   config (): start_of_week(0), number_of_weekly_transitions(0), number_of_daily_transitions(0) {}
-} config_t;
-
-uint32_t get_id();
-esp_err_t add(cluster_t *cluster, config_t *config);
-} /* schedule_configuration */
-
 namespace setback {
 
 typedef struct config {
@@ -2031,12 +2017,6 @@ uint32_t get_id();
 esp_err_t add(cluster_t *cluster);
 } /* holiday_schedules */
 
-namespace holiday_schedules {
-
-uint32_t get_id();
-esp_err_t add(cluster_t *cluster);
-} /* holiday_schedules */
-
 namespace unbolting {
 
 uint32_t get_id();
diff --git a/docs/en/developing.rst b/docs/en/developing.rst
index d9bec8240..1a54f0aeb 100644
--- a/docs/en/developing.rst
+++ b/docs/en/developing.rst
@@ -796,6 +796,7 @@ Additional clusters can also be added to an endpoint. Examples:
    ::
 
       on_off::config_t on_off_config;
+      on_off_config.feature_flags = on_off::feature::lighting::get_id();
       cluster_t *cluster = on_off::create(endpoint, &on_off_config, CLUSTER_FLAG_SERVER, on_off::feature::lighting::get_id());
 
 -  temperature_measurement:
diff --git a/examples/all_device_types_app/main/esp_matter_console_helpers.cpp b/examples/all_device_types_app/main/esp_matter_console_helpers.cpp
index 175ddd296..6102caab2 100644
--- a/examples/all_device_types_app/main/esp_matter_console_helpers.cpp
+++ b/examples/all_device_types_app/main/esp_matter_console_helpers.cpp
@@ -311,7 +311,7 @@ int create(uint8_t device_type_index)
         }
         case ESP_MATTER_OCCUPANCY_SENSOR: {
             esp_matter::endpoint::occupancy_sensor::config_t occupancy_sensor_config;
-            occupancy_sensor_config.occupancy_sensing.features = cluster::occupancy_sensing::feature::other::get_id();
+            occupancy_sensor_config.occupancy_sensing.feature_flags = cluster::occupancy_sensing::feature::other::get_id();
             endpoint = esp_matter::endpoint::occupancy_sensor::create(node, &occupancy_sensor_config, ENDPOINT_FLAG_NONE, NULL);
             break;
         }
@@ -337,7 +337,7 @@ int create(uint8_t device_type_index)
         }
         case ESP_MATTER_PUMP: {
             esp_matter::endpoint::pump::config_t pump_config;
-            pump_config.pump_configuration_and_control.features = cluster::pump_configuration_and_control::feature::constant_pressure::get_id();
+            pump_config.pump_configuration_and_control.feature_flags = cluster::pump_configuration_and_control::feature::constant_pressure::get_id();
             endpoint = esp_matter::endpoint::pump::create(node, &pump_config, ENDPOINT_FLAG_NONE, NULL);
             break;
         }
diff --git a/examples/bridge_apps/esp-now_bridge_light/main/app_main.cpp b/examples/bridge_apps/esp-now_bridge_light/main/app_main.cpp
index 073a92aa3..6d844124b 100644
--- a/examples/bridge_apps/esp-now_bridge_light/main/app_main.cpp
+++ b/examples/bridge_apps/esp-now_bridge_light/main/app_main.cpp
@@ -150,12 +150,16 @@ extern "C" void app_main()
 
     color_temperature_light::config_t light_config;
     light_config.on_off.on_off = DEFAULT_POWER;
-    light_config.on_off.lighting.start_up_on_off = nullptr;
+    light_config.on_off.features.lighting.start_up_on_off = nullptr;
     light_config.level_control.current_level = DEFAULT_BRIGHTNESS;
-    light_config.level_control.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;
+    light_config.level_control.features.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;
     light_config.color_control.color_mode = (uint8_t)ColorControl::ColorMode::kColorTemperature;
     light_config.color_control.enhanced_color_mode = (uint8_t)ColorControl::ColorMode::kColorTemperature;
-    light_config.color_control.color_temperature.startup_color_temperature_mireds = nullptr;
+    light_config.color_control.features.color_temperature.startup_color_temperature_mireds = nullptr;
+
+    light_config.on_off.feature_flags = cluster::on_off::feature::lighting::get_id();
+    light_config.level_control.feature_flags = cluster::level_control::feature::lighting::get_id();
+    light_config.color_control.feature_flags = cluster::color_control::feature::color_temperature::get_id();
 
     // endpoint handles can be used to add/modify clusters.
     endpoint_t *endpoint = color_temperature_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
diff --git a/examples/demo/badge/main/app_main.cpp b/examples/demo/badge/main/app_main.cpp
index 5a2da974e..340c60037 100644
--- a/examples/demo/badge/main/app_main.cpp
+++ b/examples/demo/badge/main/app_main.cpp
@@ -307,7 +307,8 @@ extern "C" void app_main()
 
     on_off_light::config_t light_config;
     light_config.on_off.on_off = DEFAULT_POWER;
-    light_config.on_off.lighting.start_up_on_off = nullptr;
+    light_config.on_off.features.lighting.start_up_on_off = nullptr;
+    light_config.on_off.feature_flags = cluster::on_off::feature::lighting::get_id();
     endpoint_t *endpoint = on_off_light::create(node, &light_config, ENDPOINT_FLAG_NONE, NULL);
     ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create on off light endpoint"));
 
diff --git a/examples/light/main/app_main.cpp b/examples/light/main/app_main.cpp
index e5b4e2160..6155b68d7 100644
--- a/examples/light/main/app_main.cpp
+++ b/examples/light/main/app_main.cpp
@@ -214,13 +214,17 @@ extern "C" void app_main()
 
     extended_color_light::config_t light_config;
     light_config.on_off.on_off = DEFAULT_POWER;
-    light_config.on_off.lighting.start_up_on_off = nullptr;
+    light_config.on_off.features.lighting.start_up_on_off = nullptr;
     light_config.level_control.current_level = DEFAULT_BRIGHTNESS;
     light_config.level_control.on_level = DEFAULT_BRIGHTNESS;
-    light_config.level_control.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;
+    light_config.level_control.features.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;
     light_config.color_control.color_mode = (uint8_t)ColorControl::ColorMode::kColorTemperature;
     light_config.color_control.enhanced_color_mode = (uint8_t)ColorControl::ColorMode::kColorTemperature;
-    light_config.color_control.color_temperature.startup_color_temperature_mireds = nullptr;
+    light_config.color_control.features.color_temperature.startup_color_temperature_mireds = nullptr;
+
+    light_config.on_off.feature_flags = cluster::on_off::feature::lighting::get_id();
+    light_config.level_control.feature_flags = cluster::level_control::feature::lighting::get_id();
+    light_config.color_control.feature_flags = cluster::color_control::feature::color_temperature::get_id();
 
     // endpoint handles can be used to add/modify clusters.
     endpoint_t *endpoint = extended_color_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
diff --git a/examples/light_network_prov/main/app_main.cpp b/examples/light_network_prov/main/app_main.cpp
index 9df61ff42..e290976a5 100644
--- a/examples/light_network_prov/main/app_main.cpp
+++ b/examples/light_network_prov/main/app_main.cpp
@@ -235,13 +235,17 @@ extern "C" void app_main()
 
     extended_color_light::config_t light_config;
     light_config.on_off.on_off = DEFAULT_POWER;
-    light_config.on_off.lighting.start_up_on_off = nullptr;
+    light_config.on_off.features.lighting.start_up_on_off = nullptr;
     light_config.level_control.current_level = DEFAULT_BRIGHTNESS;
     light_config.level_control.on_level = DEFAULT_BRIGHTNESS;
-    light_config.level_control.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;
+    light_config.level_control.features.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;
     light_config.color_control.color_mode = (uint8_t)ColorControl::ColorMode::kColorTemperature;
     light_config.color_control.enhanced_color_mode = (uint8_t)ColorControl::ColorMode::kColorTemperature;
-    light_config.color_control.color_temperature.startup_color_temperature_mireds = nullptr;
+    light_config.color_control.features.color_temperature.startup_color_temperature_mireds = nullptr;
+
+    light_config.on_off.feature_flags = cluster::on_off::feature::lighting::get_id();
+    light_config.level_control.feature_flags = cluster::level_control::feature::lighting::get_id();
+    light_config.color_control.feature_flags = cluster::color_control::feature::color_temperature::get_id();
 
     // endpoint handles can be used to add/modify clusters.
     endpoint_t *endpoint = extended_color_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);