Submodule update: to 111bc80

README.md

@@ -13,7 +13,7 @@ Espressif's SDK for Matter is the official Matter development framework for ESP3
 
 ## Supported ESP-IDF and connectedhomeip versions
 
-- This SDK currently works with [v1.1-branch](https://github.com/project-chip/connectedhomeip/tree/v1.1-branch) of connectedhomeip.
+- This SDK currently works with [111bc80](https://github.com/project-chip/connectedhomeip/commit/111bc80957f6f83f31770cbb65fcda3cc8657db6) of connectedhomeip.
 - For ESP32, ESP32-C3, and ESP32-S3, ESP-IDF [v5.0.1 release](https://github.com/espressif/esp-idf/releases/tag/v5.0.1) is required.
 - For ESP32-C2, ESP32-H2(preview) and ESP32-C6(preview) and Zigbee Bridge example, ESP-IDF branch at [commit ea5e0ff](https://github.com/espressif/esp-idf/tree/ea5e0ff) in branch release/v5.1 should be used.
 

components/esp_matter/CMakeLists.txt

@@ -28,6 +28,7 @@ set(SRC_DIRS_LIST       "."
                         "${MATTER_SDK_PATH}/src/app/clusters/general-diagnostics-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/group-key-mgmt-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/groups-server"
+                        "${MATTER_SDK_PATH}/src/app/clusters/icd-management-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/identify-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/keypad-input-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/level-control"
@@ -46,7 +47,7 @@ set(SRC_DIRS_LIST       "."
                         "${MATTER_SDK_PATH}/src/app/clusters/power-source-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/pump-configuration-and-control-client"
                         "${MATTER_SDK_PATH}/src/app/clusters/pump-configuration-and-control-server"
-                        "${MATTER_SDK_PATH}/src/app/clusters/scenes"
+                        "${MATTER_SDK_PATH}/src/app/clusters/scenes-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/software-diagnostics-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/switch-server"
                         "${MATTER_SDK_PATH}/src/app/clusters/target-navigator-server"

components/esp_matter/esp_matter.h

@@ -30,7 +30,7 @@ application.
 #include <esp_matter_feature.h>
 #include <esp_matter_identify.h>
 
-#include <app-common/zap-generated/att-storage.h>
+#include <app/att-storage.h>
 #include <app/server/Dnssd.h>
 #include <platform/CHIPDeviceEvent.h>
 #include <platform/CHIPDeviceLayer.h>

components/esp_matter/esp_matter_client.h

@@ -16,6 +16,7 @@
 
 #include <esp_err.h>
 #include <esp_matter_core.h>
+#include <app-common/zap-generated/cluster-objects.h>
 
 namespace esp_matter {
 namespace cluster {

components/esp_matter/esp_matter_cluster.cpp

@@ -18,7 +18,6 @@
 #include <esp_matter_cluster.h>
 #include <esp_matter_core.h>
 
-#include <app-common/zap-generated/att-storage.h>
 #include <app-common/zap-generated/callback.h>
 #include <app/PluginApplicationCallbacks.h>
 
@@ -912,10 +911,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 } /* groups */
 
 namespace scenes {
-const function_generic_t function_list[] = {
-    (function_generic_t)emberAfScenesClusterServerInitCallback,
-};
-const int function_flags = CLUSTER_FLAG_INIT_FUNCTION;
+const function_generic_t *function_list = NULL;
+const int function_flags = CLUSTER_FLAG_NONE;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
 {

components/esp_matter/esp_matter_command.cpp

@@ -426,83 +426,6 @@ static esp_err_t esp_matter_command_callback_add_group_if_identifying(const Conc
     return ESP_OK;
 }
 
-static esp_err_t esp_matter_command_callback_add_scene(const ConcreteCommandPath &command_path, TLVReader &tlv_data,
-                                                       void *opaque_ptr)
-{
-    chip::app::Clusters::Scenes::Commands::AddScene::DecodableType command_data;
-    CHIP_ERROR error = Decode(tlv_data, command_data);
-    if (error == CHIP_NO_ERROR) {
-        emberAfScenesClusterAddSceneCallback((CommandHandler *)opaque_ptr, command_path, command_data);
-    }
-    return ESP_OK;
-}
-
-static esp_err_t esp_matter_command_callback_view_scene(const ConcreteCommandPath &command_path, TLVReader &tlv_data,
-                                                        void *opaque_ptr)
-{
-    chip::app::Clusters::Scenes::Commands::ViewScene::DecodableType command_data;
-    CHIP_ERROR error = Decode(tlv_data, command_data);
-    if (error == CHIP_NO_ERROR) {
-        emberAfScenesClusterViewSceneCallback((CommandHandler *)opaque_ptr, command_path, command_data);
-    }
-    return ESP_OK;
-}
-
-static esp_err_t esp_matter_command_callback_remove_scene(const ConcreteCommandPath &command_path, TLVReader &tlv_data,
-                                                          void *opaque_ptr)
-{
-    chip::app::Clusters::Scenes::Commands::RemoveScene::DecodableType command_data;
-    CHIP_ERROR error = Decode(tlv_data, command_data);
-    if (error == CHIP_NO_ERROR) {
-        emberAfScenesClusterRemoveSceneCallback((CommandHandler *)opaque_ptr, command_path, command_data);
-    }
-    return ESP_OK;
-}
-
-static esp_err_t esp_matter_command_callback_remove_all_scenes(const ConcreteCommandPath &command_path,
-                                                               TLVReader &tlv_data, void *opaque_ptr)
-{
-    chip::app::Clusters::Scenes::Commands::RemoveAllScenes::DecodableType command_data;
-    CHIP_ERROR error = Decode(tlv_data, command_data);
-    if (error == CHIP_NO_ERROR) {
-        emberAfScenesClusterRemoveAllScenesCallback((CommandHandler *)opaque_ptr, command_path, command_data);
-    }
-    return ESP_OK;
-}
-
-static esp_err_t esp_matter_command_callback_store_scene(const ConcreteCommandPath &command_path, TLVReader &tlv_data,
-                                                         void *opaque_ptr)
-{
-    chip::app::Clusters::Scenes::Commands::StoreScene::DecodableType command_data;
-    CHIP_ERROR error = Decode(tlv_data, command_data);
-    if (error == CHIP_NO_ERROR) {
-        emberAfScenesClusterStoreSceneCallback((CommandHandler *)opaque_ptr, command_path, command_data);
-    }
-    return ESP_OK;
-}
-
-static esp_err_t esp_matter_command_callback_recall_scene(const ConcreteCommandPath &command_path, TLVReader &tlv_data,
-                                                          void *opaque_ptr)
-{
-    chip::app::Clusters::Scenes::Commands::RecallScene::DecodableType command_data;
-    CHIP_ERROR error = Decode(tlv_data, command_data);
-    if (error == CHIP_NO_ERROR) {
-        emberAfScenesClusterRecallSceneCallback((CommandHandler *)opaque_ptr, command_path, command_data);
-    }
-    return ESP_OK;
-}
-
-static esp_err_t esp_matter_command_callback_get_scene_membership(const ConcreteCommandPath &command_path,
-                                                                  TLVReader &tlv_data, void *opaque_ptr)
-{
-    chip::app::Clusters::Scenes::Commands::GetSceneMembership::DecodableType command_data;
-    CHIP_ERROR error = Decode(tlv_data, command_data);
-    if (error == CHIP_NO_ERROR) {
-        emberAfScenesClusterGetSceneMembershipCallback((CommandHandler *)opaque_ptr, command_path, command_data);
-    }
-    return ESP_OK;
-}
-
 static esp_err_t esp_matter_command_callback_off(const ConcreteCommandPath &command_path, TLVReader &tlv_data,
                                                  void *opaque_ptr)
 {
@@ -1694,44 +1617,37 @@ namespace command {
 
 command_t *create_add_scene(cluster_t *cluster)
 {
-    return esp_matter::command::create(cluster, Scenes::Commands::AddScene::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_add_scene);
+    return esp_matter::command::create(cluster, Scenes::Commands::AddScene::Id, COMMAND_FLAG_ACCEPTED, NULL);
 }
 
 command_t *create_view_scene(cluster_t *cluster)
 {
-    return esp_matter::command::create(cluster, Scenes::Commands::ViewScene::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_view_scene);
+    return esp_matter::command::create(cluster, Scenes::Commands::ViewScene::Id, COMMAND_FLAG_ACCEPTED, NULL);
 }
 
 command_t *create_remove_scene(cluster_t *cluster)
 {
-    return esp_matter::command::create(cluster, Scenes::Commands::RemoveScene::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_remove_scene);
+    return esp_matter::command::create(cluster, Scenes::Commands::RemoveScene::Id, COMMAND_FLAG_ACCEPTED, NULL);
 }
 
 command_t *create_remove_all_scenes(cluster_t *cluster)
 {
-    return esp_matter::command::create(cluster, Scenes::Commands::RemoveAllScenes::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_remove_all_scenes);
+    return esp_matter::command::create(cluster, Scenes::Commands::RemoveAllScenes::Id, COMMAND_FLAG_ACCEPTED, NULL);
 }
 
 command_t *create_store_scene(cluster_t *cluster)
 {
-    return esp_matter::command::create(cluster, Scenes::Commands::StoreScene::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_store_scene);
+    return esp_matter::command::create(cluster, Scenes::Commands::StoreScene::Id, COMMAND_FLAG_ACCEPTED, NULL);
 }
 
 command_t *create_recall_scene(cluster_t *cluster)
 {
-    return esp_matter::command::create(cluster, Scenes::Commands::RecallScene::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_recall_scene);
+    return esp_matter::command::create(cluster, Scenes::Commands::RecallScene::Id, COMMAND_FLAG_ACCEPTED, NULL);
 }
 
 command_t *create_get_scene_membership(cluster_t *cluster)
 {
-    return esp_matter::command::create(cluster, Scenes::Commands::GetSceneMembership::Id, COMMAND_FLAG_ACCEPTED,
-                                       esp_matter_command_callback_get_scene_membership);
+    return esp_matter::command::create(cluster, Scenes::Commands::GetSceneMembership::Id, COMMAND_FLAG_ACCEPTED, NULL);
 }
 
 command_t *create_add_scene_response(cluster_t *cluster)

components/esp_matter/esp_matter_feature.cpp

@@ -69,7 +69,7 @@ namespace lighting {
 
 uint32_t get_id()
 {
-    return (uint32_t)OnOff::OnOffFeature::kLighting;
+    return (uint32_t)OnOff::Feature::kLighting;
 }
 
 esp_err_t add(cluster_t *cluster, config_t *config)
@@ -104,7 +104,7 @@ namespace on_off {
 
 uint32_t get_id()
 {
-    return (uint32_t)LevelControl::LevelControlFeature::kOnOff;
+    return (uint32_t)LevelControl::Feature::kOnOff;
 }
 
 esp_err_t add(cluster_t *cluster)
@@ -124,7 +124,7 @@ namespace lighting {
 
 uint32_t get_id()
 {
-    return (uint32_t)LevelControl::LevelControlFeature::kLighting;
+    return (uint32_t)LevelControl::Feature::kLighting;
 }
 
 esp_err_t add(cluster_t *cluster, config_t *config)
@@ -150,7 +150,7 @@ namespace frequency {
 
 uint32_t get_id()
 {
-    return (uint32_t)LevelControl::LevelControlFeature::kFrequency;
+    return (uint32_t)LevelControl::Feature::kFrequency;
 }
 
 esp_err_t add(cluster_t *cluster, config_t *config)
@@ -381,7 +381,7 @@ namespace lift {
 
 uint32_t get_id()
 {
-    return (uint32_t)WindowCovering::WindowCoveringFeature::kLift;
+    return (uint32_t)WindowCovering::Feature::kLift;
 }
 
 esp_err_t add(cluster_t *cluster, config_t *config)
@@ -409,7 +409,7 @@ namespace tilt {
 
 uint32_t get_id()
 {
-    return (uint32_t)WindowCovering::WindowCoveringFeature::kTilt;
+    return (uint32_t)WindowCovering::Feature::kTilt;
 }
 
 esp_err_t add(cluster_t *cluster, config_t *config)
@@ -431,7 +431,7 @@ namespace position_aware_lift {
 
 uint32_t get_id()
 {
-    return (uint32_t)WindowCovering::WindowCoveringFeature::kPositionAwareLift;
+    return (uint32_t)WindowCovering::Feature::kPositionAwareLift;
 }
 
 esp_err_t add(cluster_t *cluster, config_t *config)
@@ -472,7 +472,7 @@ namespace absolute_position {
 
 uint32_t get_id()
 {
-    return (uint32_t)WindowCovering::WindowCoveringFeature::kAbsolutePosition;
+    return (uint32_t)WindowCovering::Feature::kAbsolutePosition;
 }
 
 esp_err_t add(cluster_t *cluster, config_t *config)
@@ -535,7 +535,7 @@ namespace position_aware_tilt {
 
 uint32_t get_id()
 {
-    return (uint32_t)WindowCovering::WindowCoveringFeature::kPositionAwareTilt;
+    return (uint32_t)WindowCovering::Feature::kPositionAwareTilt;
 }
 
 esp_err_t add(cluster_t *cluster, config_t *config)

components/esp_matter/esp_matter_identify.cpp

@@ -43,26 +43,26 @@ static esp_err_t execute_callback(callback_type_t type, uint16_t endpoint_id, ui
 static void start_cb(Identify *identify)
 {
     ESP_LOGI(TAG, "Start callback");
-    execute_callback(START, identify->mEndpoint, identify->mCurrentEffectIdentifier, identify->mEffectVariant);
+    execute_callback(START, identify->mEndpoint, static_cast<uint8_t>(identify->mCurrentEffectIdentifier), static_cast<uint8_t>(identify->mEffectVariant));
 }
 
 static void stop_cb(Identify *identify)
 {
     ESP_LOGI(TAG, "Stop callback");
-    execute_callback(STOP, identify->mEndpoint, identify->mCurrentEffectIdentifier, identify->mEffectVariant);
+    execute_callback(STOP, identify->mEndpoint, static_cast<uint8_t>(identify->mCurrentEffectIdentifier), static_cast<uint8_t>(identify->mEffectVariant));
 }
 
 static void effect_cb(Identify *identify)
 {
     ESP_LOGI(TAG, "Effect callback");
-    execute_callback(EFFECT, identify->mEndpoint, identify->mCurrentEffectIdentifier, identify->mEffectVariant);
+    execute_callback(EFFECT, identify->mEndpoint, static_cast<uint8_t>(identify->mCurrentEffectIdentifier), static_cast<uint8_t>(identify->mEffectVariant));
 }
 
 esp_err_t init(uint16_t endpoint_id, uint8_t identify_type, uint8_t effect_identifier, uint8_t effect_variant)
 {
-    Identify *identify = new Identify(endpoint_id, start_cb, stop_cb, (EmberAfIdentifyIdentifyType)identify_type,
-                                      effect_cb, static_cast<EmberAfIdentifyEffectIdentifier>(effect_identifier),
-                                      static_cast<EmberAfIdentifyEffectVariant>(effect_variant));
+    Identify *identify = new Identify(endpoint_id, start_cb, stop_cb, (chip::app::Clusters::Identify::IdentifyTypeEnum)identify_type,
+                                      effect_cb, static_cast<chip::app::Clusters::Identify::EffectIdentifierEnum>(effect_identifier),
+                                      static_cast<chip::app::Clusters::Identify::EffectVariantEnum>(effect_variant));
     if (!identify) {
         ESP_LOGE(TAG, "Fail to create identify object");
         return ESP_FAIL;

components/esp_matter/esp_matter_identify.h

@@ -69,8 +69,8 @@ esp_err_t set_callback(callback_t callback);
  * @return error in case of failure.
  */
 esp_err_t init(uint16_t endpoint_id, uint8_t identify_type,
-                uint8_t effect_identifier = EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BLINK,
-                uint8_t effect_variant = EMBER_ZCL_IDENTIFY_EFFECT_VARIANT_DEFAULT);
+                uint8_t effect_identifier = static_cast<uint8_t>(chip::app::Clusters::Identify::EffectIdentifierEnum::kBlink),
+                uint8_t effect_variant = static_cast<uint8_t>(chip::app::Clusters::Identify::EffectVariantEnum::kDefault));
 
 } /* identification */
 } /* esp_matter */

components/esp_matter/zap_common/app/callback-stub.cpp

@@ -71,8 +71,8 @@ void emberAfClusterInitCallback(EndpointId endpoint, ClusterId clusterId)
     case app::Clusters::Channel::Id:
         emberAfChannelClusterInitCallback(endpoint);
         break;
-    case app::Clusters::ClientMonitoring::Id:
-        emberAfClientMonitoringClusterInitCallback(endpoint);
+    case app::Clusters::IcdManagement::Id:
+        emberAfIcdManagementClusterInitCallback(endpoint);
         break;
     case app::Clusters::ColorControl::Id:
         emberAfColorControlClusterInitCallback(endpoint);
@@ -303,7 +303,7 @@ void __attribute__((weak)) emberAfChannelClusterInitCallback(EndpointId endpoint
     // To prevent warning
     (void) endpoint;
 }
-void __attribute__((weak)) emberAfClientMonitoringClusterInitCallback(EndpointId endpoint)
+void __attribute__((weak)) emberAfIcdManagementClusterInitCallback(EndpointId endpoint)
 {
     // To prevent warning
     (void) endpoint;

components/esp_matter/zap_common/zap-generated/gen_config.h

@@ -169,27 +169,26 @@
 
 
 /* Other cluster specific macros which are made generic */
-#define DYNAMIC_ENDPOINTS CONFIG_ESP_MATTER_MAX_DYNAMIC_ENDPOINT_COUNT
 
-#define EMBER_AF_ACCOUNT_LOGIN_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS      // used in account login
-#define EMBER_AF_APPLICATION_BASIC_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS  // used in application basic
-#define EMBER_AF_APPLICATION_LAUNCHER_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS   // used in application launcher
-#define EMBER_AF_AUDIO_OUTPUT_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS       // used in audio output
-#define EMBER_AF_CHANNEL_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS            // used in channel
-#define EMBER_AF_COLOR_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS      // used in color control
-#define EMBER_AF_CONTENT_LAUNCHER_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS   // used in content launch
-#define EMBER_AF_IDENTIFY_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS           // used in identify
-#define EMBER_AF_KEYPAD_INPUT_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS       // used in keypad input
-#define EMBER_AF_LEVEL_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS      // used in level control
-#define EMBER_AF_LOW_POWER_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS          // used in low power
-#define EMBER_AF_MEDIA_INPUT_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS        // used in media input
-#define EMBER_AF_MEDIA_PLAYBACK_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS     // used in media playback
-#define EMBER_AF_ON_OFF_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS             // used in on off
-#define EMBER_AF_OTA_SOFTWARE_UPDATE_PROVIDER_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS   // used in ota
-#define EMBER_AF_TARGET_NAVIGATOR_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS   // used in target navigator
-#define EMBER_AF_WAKE_ON_LAN_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS        // used in wake on lan
-#define EMBER_AF_WINDOW_COVERING_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS    // used in window covering
-#define EMBER_AF_DOOR_LOCK_CLUSTER_SERVER_ENDPOINT_COUNT DYNAMIC_ENDPOINTS          // used in door lock
+#define EMBER_AF_ACCOUNT_LOGIN_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT      // used in account login
+#define EMBER_AF_APPLICATION_BASIC_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT  // used in application basic
+#define EMBER_AF_APPLICATION_LAUNCHER_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT   // used in application launcher
+#define EMBER_AF_AUDIO_OUTPUT_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT       // used in audio output
+#define EMBER_AF_CHANNEL_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT            // used in channel
+#define EMBER_AF_COLOR_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT      // used in color control
+#define EMBER_AF_CONTENT_LAUNCHER_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT   // used in content launch
+#define EMBER_AF_IDENTIFY_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT           // used in identify
+#define EMBER_AF_KEYPAD_INPUT_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT       // used in keypad input
+#define EMBER_AF_LEVEL_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT      // used in level control
+#define EMBER_AF_LOW_POWER_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT          // used in low power
+#define EMBER_AF_MEDIA_INPUT_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT        // used in media input
+#define EMBER_AF_MEDIA_PLAYBACK_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT     // used in media playback
+#define EMBER_AF_ON_OFF_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT             // used in on off
+#define EMBER_AF_OTA_SOFTWARE_UPDATE_PROVIDER_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT   // used in ota
+#define EMBER_AF_TARGET_NAVIGATOR_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT   // used in target navigator
+#define EMBER_AF_WAKE_ON_LAN_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT        // used in wake on lan
+#define EMBER_AF_WINDOW_COVERING_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT    // used in window covering
+#define EMBER_AF_DOOR_LOCK_CLUSTER_SERVER_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT          // used in door lock
 
 #define MATTER_SCENES_TABLE_SIZE CONFIG_ESP_MATTER_SCENES_TABLE_SIZE        // used in scenes // TODO: check this again
 

components/esp_matter_controller/esp_matter_controller_write_command.cpp

@@ -192,7 +192,7 @@ constexpr size_t k_max_subjects_per_acl = CHIP_CONFIG_EXAMPLE_ACCESS_CONTROL_MAX
 constexpr size_t k_max_targets_per_acl = CHIP_CONFIG_EXAMPLE_ACCESS_CONTROL_MAX_TARGETS_PER_ENTRY;
 
 using acl_obj = AccessControl::Structs::AccessControlEntryStruct::Type;
-using acl_target_obj = AccessControl::Structs::Target::Type;
+using acl_target_obj = AccessControl::Structs::AccessControlTargetStruct::Type;
 typedef struct acl_attr {
     acl_obj acl_array[k_max_acl_entries];
     uint64_t subjects_array[k_max_acl_entries][k_max_subjects_per_acl];

components/esp_matter_controller/logger/zap-generated/DataModelLogger.h

@@ -21,125 +21,209 @@
 #include <lib/core/CHIPError.h>
 
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::AccessControl::Structs::AccessControlEntryStruct::DecodableType & value);
+                           const chip::app::Clusters::detail::Structs::ModeTagStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::AccessControl::Structs::AccessControlExtensionStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ContentLauncher::Structs::AdditionalInfoStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEPStruct::DecodableType & value);
+                           const chip::app::Clusters::detail::Structs::ModeOptionStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::detail::Structs::ApplicationStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Scenes::Structs::AttributeValuePair::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::PowerSource::Structs::BatChargeFaultChangeType::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::PowerSource::Structs::BatFaultChangeType::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ContentLauncher::Structs::BrandingInformationStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::BasicInformation::Structs::CapabilityMinimaStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Channel::Structs::ChannelInfoStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ContentLauncher::Structs::ContentSearchStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::DoorLock::Structs::CredentialStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ContentLauncher::Structs::DimensionStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::UnitTesting::Structs::DoubleNestedStructList::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Scenes::Structs::ExtensionFieldSet::DecodableType & value);
-static CHIP_ERROR
-LogValue(const char * label, size_t indent,
-         const chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptorStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeySetStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::MediaInput::Structs::InputInfoStruct::DecodableType & value);
+                           const chip::app::Clusters::detail::Structs::ErrorStateStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::detail::Structs::LabelStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Channel::Structs::LineupInfoStruct::DecodableType & value);
+                           const chip::app::Clusters::detail::Structs::OperationalStateStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType & value);
+                           const chip::app::Clusters::Scenes::Structs::AttributeValuePair::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ClientMonitoring::Structs::MonitoringRegistration::DecodableType & value);
+                           const chip::app::Clusters::Scenes::Structs::ExtensionFieldSet::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::DecodableType & value);
+                           const chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType & value);
+                           const chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::UnitTesting::Structs::NestedStruct::DecodableType & value);
+                           const chip::app::Clusters::AccessControl::Structs::AccessControlTargetStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::UnitTesting::Structs::NestedStructList::DecodableType & value);
+                           const chip::app::Clusters::AccessControl::Structs::AccessControlEntryStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfo::DecodableType & value);
+                           const chip::app::Clusters::AccessControl::Structs::AccessControlExtensionStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::BasicInformation::Structs::CapabilityMinimaStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::BasicInformation::Structs::ProductAppearanceStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::PowerSource::Structs::BatChargeFaultChangeType::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::PowerSource::Structs::BatFaultChangeType::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::PowerSource::Structs::WiredFaultChangeType::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfoStruct::DecodableType & value);
+
+static CHIP_ERROR
+LogValue(const char * label, size_t indent,
+         const chip::app::Clusters::NetworkCommissioning::Structs::ThreadInterfaceScanResultStruct::DecodableType & value);
+
+static CHIP_ERROR
+LogValue(const char * label, size_t indent,
+         const chip::app::Clusters::NetworkCommissioning::Structs::WiFiInterfaceScanResultStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterface::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType & value);
+                           const chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetricsStruct::DecodableType & value);
+
+static CHIP_ERROR
+LogValue(const char * label, size_t indent,
+         const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTableStruct::DecodableType & value);
+
 static CHIP_ERROR
 LogValue(const char * label, size_t indent,
          const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::AudioOutput::Structs::OutputInfoStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ContentLauncher::Structs::ParameterStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::MediaPlayback::Structs::PlaybackPositionStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::DecodableType & value);
+                           const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTableStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ModeSelect::Structs::SemanticTagStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::ContentLauncher::Structs::StyleInformationStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::AccessControl::Structs::Target::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::TargetNavigator::Structs::TargetInfoStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::Thermostat::Structs::ThermostatScheduleTransition::DecodableType & value);
+                           const chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::DecodableType & value);
+
 static CHIP_ERROR
 LogValue(const char * label, size_t indent,
-         const chip::app::Clusters::NetworkCommissioning::Structs::ThreadInterfaceScanResult::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetricsStruct::DecodableType & value);
+         const chip::app::Clusters::TimeSynchronization::Structs::FabricScopedTrustedTimeSourceStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::DecodableType & value);
+
 static CHIP_ERROR
 LogValue(const char * label, size_t indent,
-         const chip::app::Clusters::NetworkCommissioning::Structs::WiFiInterfaceScanResult::DecodableType & value);
+         const chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::DecodableType & value);
+
+static CHIP_ERROR
+LogValue(const char * label, size_t indent,
+         const chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptorStruct::DecodableType & value);
+
 static CHIP_ERROR LogValue(const char * label, size_t indent,
-                           const chip::app::Clusters::PowerSource::Structs::WiredFaultChangeType::DecodableType & value);
+                           const chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeySetStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::IcdManagement::Structs::MonitoringRegistrationStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ModeSelect::Structs::SemanticTagStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::DoorLock::Structs::CredentialStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::Thermostat::Structs::ThermostatScheduleTransition::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::Channel::Structs::ChannelInfoStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::Channel::Structs::LineupInfoStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::TargetNavigator::Structs::TargetInfoStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::MediaPlayback::Structs::PlaybackPositionStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::MediaInput::Structs::InputInfoStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ContentLauncher::Structs::DimensionStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ContentLauncher::Structs::AdditionalInfoStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ContentLauncher::Structs::ParameterStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ContentLauncher::Structs::ContentSearchStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ContentLauncher::Structs::StyleInformationStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ContentLauncher::Structs::BrandingInformationStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::AudioOutput::Structs::OutputInfoStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEPStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::UnitTesting::Structs::NestedStruct::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::UnitTesting::Structs::NestedStructList::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::UnitTesting::Structs::DoubleNestedStructList::DecodableType & value);
+
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::DecodableType & value);
 
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::AccessControl::Events::AccessControlEntryChanged::DecodableType & value);
@@ -189,6 +273,16 @@ static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::WiFiNetworkDiagnostics::Events::AssociationFailure::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::WiFiNetworkDiagnostics::Events::ConnectionStatus::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::TimeSynchronization::Events::DSTTableEmpty::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::TimeSynchronization::Events::DSTStatus::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::TimeSynchronization::Events::TimeZoneStatus::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::TimeSynchronization::Events::TimeFailure::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::TimeSynchronization::Events::MissingTrustedTimeSource::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::BridgedDeviceBasicInformation::Events::StartUp::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
@@ -214,6 +308,40 @@ static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::Switch::Events::MultiPressComplete::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::BooleanState::Events::StateChange::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::RefrigeratorAlarm::Events::Notify::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::SmokeAlarm::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::COAlarm::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::LowBattery::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::HardwareFault::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::EndOfService::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::SelfTestComplete::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::AlarmMuted::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::MuteEnded::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::InterconnectSmokeAlarm::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::InterconnectCOAlarm::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::SmokeCoAlarm::Events::AllClear::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::DishwasherAlarm::Events::Notify::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::OperationalState::Events::OperationalError::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::OperationalState::Events::OperationCompletion::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::RvcOperationalState::Events::OperationalError::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::RvcOperationalState::Events::OperationCompletion::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::DoorLock::Events::DoorLockAlarm::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
@@ -321,6 +449,8 @@ LogValue(const char * label, size_t indent,
          const chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetworkResponse::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::TimeSynchronization::Commands::SetTimeZoneResponse::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::OperationalCredentials::Commands::AttestationResponse::DecodableType & value);
 static CHIP_ERROR
@@ -335,6 +465,26 @@ static CHIP_ERROR LogValue(const char * label, size_t indent,
 static CHIP_ERROR
 LogValue(const char * label, size_t indent,
          const chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndicesResponse::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::IcdManagement::Commands::RegisterClientResponse::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::LaundryWasherMode::Commands::ChangeToModeResponse::DecodableType & value);
+static CHIP_ERROR
+LogValue(const char * label, size_t indent,
+         const chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Commands::ChangeToModeResponse::DecodableType &
+             value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::RvcRunMode::Commands::ChangeToModeResponse::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::RvcCleanMode::Commands::ChangeToModeResponse::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
+                           const chip::app::Clusters::DishwasherMode::Commands::ChangeToModeResponse::DecodableType & value);
+static CHIP_ERROR
+LogValue(const char * label, size_t indent,
+         const chip::app::Clusters::OperationalState::Commands::OperationalCommandResponse::DecodableType & value);
+static CHIP_ERROR
+LogValue(const char * label, size_t indent,
+         const chip::app::Clusters::RvcOperationalState::Commands::OperationalCommandResponse::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,
                            const chip::app::Clusters::DoorLock::Commands::GetWeekDayScheduleResponse::DecodableType & value);
 static CHIP_ERROR LogValue(const char * label, size_t indent,

examples/common/blemesh_platform/platform/ESP32_custom/BUILD.gn

@@ -33,6 +33,7 @@ declare_args() {
   chip_max_discovered_ip_addresses = 5
   chip_use_secure_cert_dac_provider = false
   chip_use_esp32_ecdsa_peripheral = false
+  chip_enable_route_hook = false
 }
 
 config("ESP32_custom_include") {

examples/common/external_platform/BUILD.gn

@@ -28,6 +28,7 @@ declare_args() {
   chip_bt_nimble_enabled = true
   chip_bt_bluedroid_enabled = true
   chip_max_discovered_ip_addresses = 5
+  chip_enable_route_hook = false
 }
 
 config("ESP32_custom_include") {

examples/controller/sdkconfig.defaults

@@ -37,6 +37,7 @@ CONFIG_ESP_MAIN_TASK_STACK_SIZE=10240
 CONFIG_NUM_UDP_ENDPOINTS=16
 
 # Enable Controller and commissioner
+CONFIG_ENABLE_CHIP_CONTROLLER_BUILD=y
 CONFIG_ESP_MATTER_CONTROLLER_ENABLE=y
 CONFIG_ESP_MATTER_COMMISSIONER_ENABLE=y