diff --git a/src/android/CHIPTool/.idea/runConfigurations.xml b/src/android/CHIPTool/.idea/runConfigurations.xml
deleted file mode 100644
index 7f68460d8b38ac..00000000000000
--- a/src/android/CHIPTool/.idea/runConfigurations.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RunConfigurationProducerService">
-    <option name="ignoredProducers">
-      <set>
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
-      </set>
-    </option>
-  </component>
-</project>
\ No newline at end of file
diff --git a/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/WildcardFragment.kt b/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/WildcardFragment.kt
index d17bff19d2e1ab..063e8886f310a3 100644
--- a/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/WildcardFragment.kt
+++ b/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/WildcardFragment.kt
@@ -13,8 +13,11 @@ import androidx.lifecycle.lifecycleScope
 import chip.devicecontroller.ChipDeviceController
 import chip.devicecontroller.ChipIdLookup
 import chip.devicecontroller.ReportCallback
+import chip.devicecontroller.ReportEventCallback
+import chip.devicecontroller.ResubscriptionAttemptCallback
 import chip.devicecontroller.SubscriptionEstablishedCallback
 import chip.devicecontroller.model.ChipAttributePath
+import chip.devicecontroller.model.ChipEventPath
 import chip.devicecontroller.model.ChipPathId
 import chip.devicecontroller.model.NodeState
 import com.google.chip.chiptool.ChipClient
@@ -23,9 +26,12 @@ import java.lang.StringBuilder
 import kotlinx.android.synthetic.main.wildcard_fragment.attributeIdEd
 import kotlinx.android.synthetic.main.wildcard_fragment.clusterIdEd
 import kotlinx.android.synthetic.main.wildcard_fragment.endpointIdEd
+import kotlinx.android.synthetic.main.wildcard_fragment.eventIdEd
 import kotlinx.android.synthetic.main.wildcard_fragment.outputTv
 import kotlinx.android.synthetic.main.wildcard_fragment.view.readBtn
+import kotlinx.android.synthetic.main.wildcard_fragment.view.readEventBtn
 import kotlinx.android.synthetic.main.wildcard_fragment.view.subscribeBtn
+import kotlinx.android.synthetic.main.wildcard_fragment.view.subscribeEventBtn
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 
@@ -49,6 +55,28 @@ class WildcardFragment : Fragment() {
       Log.i(TAG, debugString)
       requireActivity().runOnUiThread { outputTv.text = debugString }
     }
+
+    override fun onDone() {
+      Log.i(TAG, "wildcard report Done")
+    }
+  }
+
+  private val reportEventCallback = object : ReportEventCallback {
+    override fun onError(eventPath: ChipEventPath, ex: Exception) {
+      Log.e(TAG, "Report error for $eventPath: $ex")
+    }
+
+    override fun onReport(nodeState: NodeState) {
+      Log.i(TAG, "Received wildcard report")
+
+      val debugString = nodeStateToDebugString(nodeState)
+      Log.i(TAG, debugString)
+      requireActivity().runOnUiThread { outputTv.text = debugString }
+    }
+
+    override fun onDone() {
+      Log.i(TAG, "wildcard report Done")
+    }
   }
 
   override fun onCreateView(
@@ -58,8 +86,10 @@ class WildcardFragment : Fragment() {
   ): View {
     scope = viewLifecycleOwner.lifecycleScope
     return inflater.inflate(R.layout.wildcard_fragment, container, false).apply {
-      subscribeBtn.setOnClickListener { scope.launch { showSubscribeDialog() } }
-      readBtn.setOnClickListener { scope.launch { read() } }
+      subscribeBtn.setOnClickListener { scope.launch { showSubscribeDialog(ATTRIBUTE) } }
+      readBtn.setOnClickListener { scope.launch { read(ATTRIBUTE) } }
+      subscribeEventBtn.setOnClickListener { scope.launch { showSubscribeDialog(EVENT) } }
+      readEventBtn.setOnClickListener { scope.launch { read(EVENT) } }
 
       addressUpdateFragment =
         childFragmentManager.findFragmentById(R.id.addressUpdateFragment) as AddressUpdateFragment
@@ -76,6 +106,10 @@ class WildcardFragment : Fragment() {
           val attributeName = ChipIdLookup.attributeIdToName(clusterId, attributeId)
           stringBuilder.append("\t\t$attributeName: ${attributeState.value}\n")
         }
+        clusterState.eventStates.forEach { (eventId, eventState) ->
+          val eventName = ChipIdLookup.eventIdToName(clusterId, eventId)
+          stringBuilder.append("\t\t$eventName: ${eventState.value}\n")
+        }
         stringBuilder.append("\t}\n")
       }
       stringBuilder.append("}\n")
@@ -83,37 +117,63 @@ class WildcardFragment : Fragment() {
     return stringBuilder.toString()
   }
 
-  private suspend fun subscribe(minInterval: Int, maxInterval: Int) {
+  private suspend fun subscribe(type: Int, minInterval: Int, maxInterval: Int) {
     val subscriptionEstablishedCallback =
       SubscriptionEstablishedCallback { Log.i(TAG, "Subscription to device established") }
 
+    val resubscriptionAttemptCallback =
+      ResubscriptionAttemptCallback { terminationCause, nextResubscribeIntervalMsec
+                                     -> Log.i(TAG, "ResubscriptionAttempt terminationCause:$terminationCause, nextResubscribeIntervalMsec:$nextResubscribeIntervalMsec") }
+
     val endpointId = getChipPathIdForText(endpointIdEd.text.toString())
     val clusterId = getChipPathIdForText(clusterIdEd.text.toString())
     val attributeId = getChipPathIdForText(attributeIdEd.text.toString())
-    val attributePath = ChipAttributePath.newInstance(endpointId, clusterId, attributeId)
-
-    deviceController.subscribeToPath(subscriptionEstablishedCallback,
-                                     reportCallback,
-                                     ChipClient.getConnectedDevicePointer(requireContext(),
-                                                                          addressUpdateFragment.deviceId),
-                                     listOf(attributePath),
-                                     minInterval,
-                                     maxInterval)
+    val eventId = getChipPathIdForText(eventIdEd.text.toString())
+
+    if (type == ATTRIBUTE) {
+      val attributePath = ChipAttributePath.newInstance(endpointId, clusterId, attributeId)
+      deviceController.subscribeToPath(subscriptionEstablishedCallback,
+                                       reportCallback,
+                                       ChipClient.getConnectedDevicePointer(requireContext(),
+                                       addressUpdateFragment.deviceId),
+                                       listOf(attributePath),
+                                       minInterval,
+                                       maxInterval)
+    } else if (type == EVENT) {
+      val eventPath = ChipEventPath.newInstance(endpointId, clusterId, eventId)
+      deviceController.subscribeToEventPath(subscriptionEstablishedCallback,
+                                      resubscriptionAttemptCallback,
+                                      reportEventCallback,
+                                      ChipClient.getConnectedDevicePointer(requireContext(),
+                                      addressUpdateFragment.deviceId),
+                                      listOf(eventPath),
+                                      minInterval,
+                                      maxInterval)
+    }
   }
 
-  private suspend fun read() {
+  private suspend fun read(type: Int) {
     val endpointId = getChipPathIdForText(endpointIdEd.text.toString())
     val clusterId = getChipPathIdForText(clusterIdEd.text.toString())
     val attributeId = getChipPathIdForText(attributeIdEd.text.toString())
-    val attributePath = ChipAttributePath.newInstance(endpointId, clusterId, attributeId)
-
-    deviceController.readPath(reportCallback,
-                              ChipClient.getConnectedDevicePointer(requireContext(),
-                                                                   addressUpdateFragment.deviceId),
-                              listOf(attributePath))
+    val eventId = getChipPathIdForText(eventIdEd.text.toString())
+
+    if (type == ATTRIBUTE) {
+      val attributePath = ChipAttributePath.newInstance(endpointId, clusterId, attributeId)
+      deviceController.readPath(reportCallback,
+                          ChipClient.getConnectedDevicePointer(requireContext(),
+                          addressUpdateFragment.deviceId),
+                          listOf(attributePath))
+    } else if (type == EVENT) {
+      val eventPath = ChipEventPath.newInstance(endpointId, clusterId, eventId)
+      deviceController.readEventPath(reportEventCallback,
+                          ChipClient.getConnectedDevicePointer(requireContext(),
+                          addressUpdateFragment.deviceId),
+                          listOf(eventPath))
+    }
   }
 
-  private fun showSubscribeDialog() {
+  private fun showSubscribeDialog(type: Int) {
     val dialogView = requireActivity().layoutInflater.inflate(R.layout.subscribe_dialog, null)
     val dialog = AlertDialog.Builder(requireContext()).apply {
       setView(dialogView)
@@ -123,7 +183,7 @@ class WildcardFragment : Fragment() {
     val maxIntervalEd = dialogView.findViewById<EditText>(R.id.maxIntervalEd)
     dialogView.findViewById<Button>(R.id.subscribeBtn).setOnClickListener {
       scope.launch {
-        subscribe(minIntervalEd.text.toString().toInt(), maxIntervalEd.text.toString().toInt())
+        subscribe(type, minIntervalEd.text.toString().toInt(), maxIntervalEd.text.toString().toInt())
         requireActivity().runOnUiThread { dialog.dismiss() }
       }
     }
@@ -136,7 +196,8 @@ class WildcardFragment : Fragment() {
 
   companion object {
     private const val TAG = "WildcardFragment"
-
+    private const val ATTRIBUTE = 1
+    private const val EVENT = 2
     fun newInstance(): WildcardFragment = WildcardFragment()
   }
 }
\ No newline at end of file
diff --git a/src/android/CHIPTool/app/src/main/res/layout/wildcard_fragment.xml b/src/android/CHIPTool/app/src/main/res/layout/wildcard_fragment.xml
index 23c5a237fa1f8a..582b1ab3c00d25 100644
--- a/src/android/CHIPTool/app/src/main/res/layout/wildcard_fragment.xml
+++ b/src/android/CHIPTool/app/src/main/res/layout/wildcard_fragment.xml
@@ -20,7 +20,7 @@
       android:layout_width="0dp"
       android:layout_height="wrap_content"
       android:layout_marginTop="8dp"
-      app:constraint_referenced_ids="endpointIdLabel,endpointIdEd,clusterIdLabel,clusterIdEd,attributeIdLabel,attributeIdEd"
+      app:constraint_referenced_ids="endpointIdLabel,endpointIdEd,clusterIdLabel,clusterIdEd,attributeIdLabel,attributeIdEd,eventIdLabel,eventIdEd"
       app:flow_horizontalBias="0.0"
       app:flow_horizontalGap="8dp"
       app:flow_horizontalStyle="packed"
@@ -76,6 +76,21 @@
       android:inputType="number"
       android:hint="@string/wildcard_help_label"/>
 
+  <TextView
+      android:id="@+id/eventIdLabel"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:padding="8dp"
+      android:textSize="16sp"
+      android:text="@string/event_id_label" />
+
+  <EditText
+      android:id="@+id/eventIdEd"
+      android:layout_width="0dp"
+      android:layout_height="wrap_content"
+      android:layout_margin="16dp"
+      android:inputType="number"
+      android:hint="@string/wildcard_help_label"/>
   <Button
       android:id="@+id/readBtn"
       android:layout_width="wrap_content"
@@ -90,19 +105,47 @@
       app:layout_constraintEnd_toStartOf="@id/subscribeBtn"
       app:layout_constraintTop_toBottomOf="@id/flow"/>
 
-    <Button
-        android:id="@+id/subscribeBtn"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:padding="16dp"
-        android:layout_marginTop="16dp"
-        android:layout_marginBottom="8dp"
-        android:layout_gravity="center"
-        android:text="@string/wildcard_subscribe_btn_text"
-        android:textSize="16sp"
-        app:layout_constraintStart_toEndOf="@id/readBtn"
-        app:layout_constraintEnd_toEndOf="parent"
-        app:layout_constraintTop_toBottomOf="@id/flow"/>
+  <Button
+      android:id="@+id/subscribeBtn"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:padding="16dp"
+      android:layout_marginTop="16dp"
+      android:layout_marginBottom="8dp"
+      android:layout_gravity="center"
+      android:text="@string/wildcard_subscribe_btn_text"
+      android:textSize="16sp"
+      app:layout_constraintStart_toEndOf="@id/readBtn"
+      app:layout_constraintEnd_toEndOf="parent"
+      app:layout_constraintTop_toBottomOf="@id/flow"/>
+
+  <Button
+      android:id="@+id/readEventBtn"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:padding="16dp"
+      android:layout_marginTop="16dp"
+      android:layout_marginBottom="8dp"
+      android:layout_gravity="center"
+      android:text="@string/wildcard_read_event_btn_text"
+      android:textSize="16sp"
+      app:layout_constraintStart_toStartOf="parent"
+      app:layout_constraintEnd_toStartOf="@id/subscribeEventBtn"
+      app:layout_constraintTop_toBottomOf="@id/readBtn"/>
+
+  <Button
+      android:id="@+id/subscribeEventBtn"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:padding="16dp"
+      android:layout_marginTop="16dp"
+      android:layout_marginBottom="8dp"
+      android:layout_gravity="center"
+      android:text="@string/wildcard_subscribe_event_btn_text"
+      android:textSize="16sp"
+      app:layout_constraintStart_toEndOf="@id/readEventBtn"
+      app:layout_constraintEnd_toEndOf="parent"
+      app:layout_constraintTop_toBottomOf="@id/subscribeBtn"/>
 
   <ScrollView
       android:layout_width="match_parent"
@@ -110,7 +153,7 @@
       android:fadeScrollbars="false"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintStart_toStartOf="parent"
-      app:layout_constraintTop_toBottomOf="@id/subscribeBtn">
+      app:layout_constraintTop_toBottomOf="@id/subscribeEventBtn">
     <TextView
         android:id="@+id/outputTv"
         android:layout_width="match_parent"
diff --git a/src/android/CHIPTool/app/src/main/res/values/strings.xml b/src/android/CHIPTool/app/src/main/res/values/strings.xml
index 6c187c56d4f1dc..a3c0a0065a67bc 100644
--- a/src/android/CHIPTool/app/src/main/res/values/strings.xml
+++ b/src/android/CHIPTool/app/src/main/res/values/strings.xml
@@ -141,9 +141,12 @@
     <string name="endpoint_id_label">Endpoint ID</string>
     <string name="cluster_id_label">Cluster ID</string>
     <string name="attribute_id_label">Attribute ID</string>
+    <string name="event_id_label">Event ID</string>
     <string name="wildcard_help_label">Leave blank for wildcard</string>
     <string name="wildcard_subscribe_btn_text">Subscribe</string>
     <string name="wildcard_read_btn_text">Read</string>
+    <string name="wildcard_subscribe_event_btn_text">Subscribe Event</string>
+    <string name="wildcard_read_event_btn_text">Read Event</string>
 
     <string name="provision_custom_flow_btn_text">Provision CHIP device with Custom Flow</string>
     <string name="chip_device_info_commissioning_flow_label">Commissioning Flow:</string>
diff --git a/src/controller/java/AndroidCallbacks-JNI.cpp b/src/controller/java/AndroidCallbacks-JNI.cpp
index 02c704ed549dcf..8187394ec095ae 100644
--- a/src/controller/java/AndroidCallbacks-JNI.cpp
+++ b/src/controller/java/AndroidCallbacks-JNI.cpp
@@ -53,3 +53,19 @@ JNI_METHOD(void, ReportCallbackJni, deleteCallback)(JNIEnv * env, jobject self,
     VerifyOrReturn(reportCallback != nullptr, ChipLogError(Controller, "ReportCallback handle is nullptr"));
     delete reportCallback;
 }
+
+JNI_METHOD(jlong, ReportEventCallbackJni, newCallback)
+(JNIEnv * env, jobject self, jobject subscriptionEstablishedCallbackJava, jobject reportCallbackJava,
+ jobject resubscriptionAttemptCallbackJava)
+{
+    ReportEventCallback * reportCallback = chip::Platform::New<ReportEventCallback>(
+        self, subscriptionEstablishedCallbackJava, reportCallbackJava, resubscriptionAttemptCallbackJava);
+    return reinterpret_cast<jlong>(reportCallback);
+}
+
+JNI_METHOD(void, ReportEventCallbackJni, deleteCallback)(JNIEnv * env, jobject self, jlong callbackHandle)
+{
+    ReportEventCallback * reportCallback = reinterpret_cast<ReportEventCallback *>(callbackHandle);
+    VerifyOrReturn(reportCallback != nullptr, ChipLogError(Controller, "ReportCallback handle is nullptr"));
+    delete reportCallback;
+}
diff --git a/src/controller/java/AndroidCallbacks.cpp b/src/controller/java/AndroidCallbacks.cpp
index afc2670be5d794..19850a13cb25dd 100644
--- a/src/controller/java/AndroidCallbacks.cpp
+++ b/src/controller/java/AndroidCallbacks.cpp
@@ -18,6 +18,7 @@
 
 #include <controller/java/AndroidClusterExceptions.h>
 #include <controller/java/CHIPAttributeTLVValueDecoder.h>
+#include <controller/java/CHIPEventTLVValueDecoder.h>
 #include <jni.h>
 #include <lib/support/CHIPJNIError.h>
 #include <lib/support/CodeUtils.h>
@@ -298,6 +299,16 @@ void ReportCallback::OnError(CHIP_ERROR aError)
 
 void ReportCallback::OnDone(app::ReadClient *)
 {
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
+
+    jmethodID onDoneMethod;
+    err = JniReferences::GetInstance().FindMethod(env, mReportCallbackRef, "onDone", "()V", &onDoneMethod);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onDone method"));
+
+    DeviceLayer::StackUnlock unlock;
+    env->CallVoidMethod(mReportCallbackRef, onDoneMethod);
+
     JniReferences::GetInstance().GetEnvForCurrentThread()->DeleteGlobalRef(mWrapperCallbackRef);
 }
 
@@ -335,5 +346,247 @@ void ReportCallback::ReportError(jobject attributePath, const char * message, Ch
     env->CallVoidMethod(mReportCallbackRef, onErrorMethod, attributePath, exception);
 }
 
+ReportEventCallback::ReportEventCallback(jobject wrapperCallback, jobject subscriptionEstablishedCallback, jobject reportCallback,
+                                         jobject resubscriptionAttemptCallback) :
+    mBufferedReadAdapter(*this)
+{
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturn(env != nullptr, ChipLogError(Controller, "Could not get JNIEnv for current thread"));
+    if (subscriptionEstablishedCallback != nullptr)
+    {
+        mSubscriptionEstablishedCallbackRef = env->NewGlobalRef(subscriptionEstablishedCallback);
+        if (mSubscriptionEstablishedCallbackRef == nullptr)
+        {
+            ChipLogError(Controller, "Could not create global reference for Java callback");
+        }
+    }
+    mReportCallbackRef = env->NewGlobalRef(reportCallback);
+    if (mReportCallbackRef == nullptr)
+    {
+        ChipLogError(Controller, "Could not create global reference for Java callback");
+    }
+    mWrapperCallbackRef = env->NewGlobalRef(wrapperCallback);
+    if (mWrapperCallbackRef == nullptr)
+    {
+        ChipLogError(Controller, "Could not create global reference for Java callback");
+    }
+    if (resubscriptionAttemptCallback != nullptr)
+    {
+        mResubscriptionAttemptCallbackRef = env->NewGlobalRef(resubscriptionAttemptCallback);
+        if (mResubscriptionAttemptCallbackRef == nullptr)
+        {
+            ChipLogError(Controller, "Could not create global reference for Java callback");
+        }
+    }
+}
+
+ReportEventCallback::~ReportEventCallback()
+{
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturn(env != nullptr, ChipLogError(Controller, "Could not get JNIEnv for current thread"));
+    if (mSubscriptionEstablishedCallbackRef != nullptr)
+    {
+        env->DeleteGlobalRef(mSubscriptionEstablishedCallbackRef);
+    }
+    env->DeleteGlobalRef(mReportCallbackRef);
+    if (mReadClient != nullptr)
+    {
+        Platform::Delete(mReadClient);
+    }
+}
+
+void ReportEventCallback::OnReportBegin()
+{
+    JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    err = JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/model/NodeState", mNodeStateCls);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Could not get NodeState class"));
+    jmethodID nodeStateCtor = env->GetMethodID(mNodeStateCls, "<init>", "(Ljava/util/Map;)V");
+    VerifyOrReturn(nodeStateCtor != nullptr, ChipLogError(Controller, "Could not find NodeState constructor"));
+
+    jobject map = nullptr;
+    err         = JniReferences::GetInstance().CreateHashMap(map);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Could not create HashMap"));
+    mNodeStateObj = env->NewObject(mNodeStateCls, nodeStateCtor, map);
+}
+
+void ReportEventCallback::OnReportEnd()
+{
+    // Transform C++ jobject pair list to a Java HashMap, and call onReport() on the Java callback.
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
+
+    jmethodID onReportMethod;
+    err = JniReferences::GetInstance().FindMethod(env, mReportCallbackRef, "onReport", "(Lchip/devicecontroller/model/NodeState;)V",
+                                                  &onReportMethod);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onReport method"));
+
+    DeviceLayer::StackUnlock unlock;
+    env->CallVoidMethod(mReportCallbackRef, onReportMethod, mNodeStateObj);
+}
+
+void ReportEventCallback::OnEventData(const app::EventHeader & aEventHeader, TLV::TLVReader * apData,
+                                      const app::StatusIB * apStatus)
+{
+    CHIP_ERROR err       = CHIP_NO_ERROR;
+    JNIEnv * env         = JniReferences::GetInstance().GetEnvForCurrentThread();
+    jobject eventPathObj = nullptr;
+    err                  = CreateChipEventPath(aEventHeader.mPath, eventPathObj);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Unable to create Java ChipEventPath: %s", ErrorStr(err)));
+
+    if (apData == nullptr)
+    {
+        ReportError(eventPathObj, CHIP_ERROR_INVALID_ARGUMENT);
+        return;
+    }
+
+    TLV::TLVReader readerForJavaObject;
+    TLV::TLVReader readerForJavaTLV;
+    TLV::TLVReader readerForJson;
+    readerForJavaObject.Init(*apData);
+    readerForJavaTLV.Init(*apData);
+    readerForJson.Init(*apData);
+
+    jobject value = DecodeEventValue(aEventHeader.mPath, readerForJavaObject, &err);
+    // If we don't know this event, just skip it.
+    VerifyOrReturn(err != CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ReportError(eventPathObj, err));
+    VerifyOrReturn(!env->ExceptionCheck(), env->ExceptionDescribe(), ReportError(eventPathObj, CHIP_JNI_ERROR_EXCEPTION_THROWN));
+
+    // Create TLV byte array to pass to Java layer
+    size_t bufferLen                  = readerForJavaTLV.GetRemainingLength() + readerForJavaTLV.GetLengthRead();
+    std::unique_ptr<uint8_t[]> buffer = std::unique_ptr<uint8_t[]>(new uint8_t[bufferLen]);
+    uint32_t size                     = 0;
+    // The TLVReader's read head is not pointing to the first element in the container, instead of the container itself, use
+    // a TLVWriter to get a TLV with a normalized TLV buffer (Wrapped with an anonymous tag, no extra "end of container" tag
+    // at the end.)
+    TLV::TLVWriter writer;
+    writer.Init(buffer.get(), bufferLen);
+    err = writer.CopyElement(TLV::AnonymousTag(), readerForJavaTLV);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ReportError(eventPathObj, err));
+    size = writer.GetLengthWritten();
+    chip::ByteArray jniByteArray(env, reinterpret_cast<jbyte *>(buffer.get()), size);
+
+    // Convert TLV to JSON
+    Json::Value json;
+    err = TlvToJson(readerForJson, json);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ReportError(eventPathObj, err));
+
+    UtfString jsonString(env, JsonToString(json).c_str());
+
+    // Create EventState object
+    jclass eventStateCls;
+    err = JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/model/EventState", eventStateCls);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find EventState class"));
+    VerifyOrReturn(eventStateCls != nullptr, ChipLogError(Controller, "Could not find EventState class"));
+    chip::JniClass eventStateJniCls(eventStateCls);
+    jmethodID eventStateCtor = env->GetMethodID(eventStateCls, "<init>", "(Ljava/lang/Object;[BLjava/lang/String;)V");
+    VerifyOrReturn(eventStateCtor != nullptr, ChipLogError(Controller, "Could not find EventState constructor"));
+    jobject eventStateObj = env->NewObject(eventStateCls, eventStateCtor, value, jniByteArray.jniValue(), jsonString.jniValue());
+    VerifyOrReturn(eventStateObj != nullptr, ChipLogError(Controller, "Could not create EventState object"));
+
+    // Add EventState to NodeState
+    jmethodID addEventMethod;
+    err = JniReferences::GetInstance().FindMethod(env, mNodeStateObj, "addEvent", "(IJJLchip/devicecontroller/model/EventState;)V",
+                                                  &addEventMethod);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find addEvent method"));
+    env->CallVoidMethod(mNodeStateObj, addEventMethod, static_cast<jint>(aEventHeader.mPath.mEndpointId),
+                        static_cast<jlong>(aEventHeader.mPath.mClusterId), static_cast<jlong>(aEventHeader.mPath.mEventId),
+                        eventStateObj);
+    VerifyOrReturnError(!env->ExceptionCheck(), env->ExceptionDescribe());
+}
+
+CHIP_ERROR ReportEventCallback::CreateChipEventPath(const app::ConcreteEventPath & aPath, jobject & outObj)
+{
+    JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    jclass eventPathCls = nullptr;
+    err                 = JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/model/ChipEventPath", eventPathCls);
+    VerifyOrReturnError(err == CHIP_NO_ERROR, err);
+    JniClass eventPathJniCls(eventPathCls);
+
+    jmethodID eventPathCtor =
+        env->GetStaticMethodID(eventPathCls, "newInstance", "(JJJ)Lchip/devicecontroller/model/ChipEventPath;");
+    VerifyOrReturnError(eventPathCtor != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+    outObj = env->CallStaticObjectMethod(eventPathCls, eventPathCtor, aPath.mEndpointId, aPath.mClusterId, aPath.mEventId);
+    VerifyOrReturnError(outObj != nullptr, CHIP_JNI_ERROR_NULL_OBJECT);
+
+    return err;
+}
+
+void ReportEventCallback::OnError(CHIP_ERROR aError)
+{
+    ReportError(nullptr, aError);
+}
+
+void ReportEventCallback::OnDone(app::ReadClient *)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
+
+    jmethodID onDoneMethod;
+    err = JniReferences::GetInstance().FindMethod(env, mReportCallbackRef, "onDone", "()V", &onDoneMethod);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onDone method"));
+
+    DeviceLayer::StackUnlock unlock;
+    env->CallVoidMethod(mReportCallbackRef, onDoneMethod);
+
+    JniReferences::GetInstance().GetEnvForCurrentThread()->DeleteGlobalRef(mWrapperCallbackRef);
+}
+
+void ReportEventCallback::OnSubscriptionEstablished(SubscriptionId aSubscriptionId)
+{
+    JniReferences::GetInstance().CallSubscriptionEstablished(mSubscriptionEstablishedCallbackRef);
+}
+
+void ReportEventCallback::OnResubscriptionAttempt(CHIP_ERROR aTerminationCause, uint32_t aNextResubscribeIntervalMsec)
+{
+    VerifyOrReturn(mResubscriptionAttemptCallbackRef != nullptr,
+                   ChipLogError(Controller, "mResubscriptionAttemptCallbackRef is null"));
+
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
+
+    jmethodID onResubscriptionAttemptMethod;
+    err = JniReferences::GetInstance().FindMethod(env, mResubscriptionAttemptCallbackRef, "onResubscriptionAttempt", "(II)V",
+                                                  &onResubscriptionAttemptMethod);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onResubscriptionAttempt method"));
+
+    DeviceLayer::StackUnlock unlock;
+    env->CallVoidMethod(mResubscriptionAttemptCallbackRef, onResubscriptionAttemptMethod, aTerminationCause.AsInteger(),
+                        aNextResubscribeIntervalMsec);
+}
+
+void ReportEventCallback::ReportError(jobject attributePath, CHIP_ERROR err)
+{
+    ReportError(attributePath, ErrorStr(err), err.AsInteger());
+}
+
+void ReportEventCallback::ReportError(jobject attributePath, Protocols::InteractionModel::Status status)
+{
+    ReportError(attributePath, "IM Status", static_cast<std::underlying_type_t<Protocols::InteractionModel::Status>>(status));
+}
+
+void ReportEventCallback::ReportError(jobject attributePath, const char * message, ChipError::StorageType errorCode)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
+
+    jthrowable exception;
+    err = AndroidClusterExceptions::GetInstance().CreateIllegalStateException(env, message, errorCode, exception);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Unable to create IllegalStateException: %s", ErrorStr(err)));
+
+    jmethodID onErrorMethod;
+    err = JniReferences::GetInstance().FindMethod(
+        env, mReportCallbackRef, "onError", "(Lchip/devicecontroller/model/ChipEventPath;Ljava/lang/Exception;)V", &onErrorMethod);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Unable to find onError method: %s", ErrorStr(err)));
+
+    DeviceLayer::StackUnlock unlock;
+    env->CallVoidMethod(mReportCallbackRef, onErrorMethod, attributePath, exception);
+}
+
 } // namespace Controller
 } // namespace chip
diff --git a/src/controller/java/AndroidCallbacks.h b/src/controller/java/AndroidCallbacks.h
index 420b826a33eea8..51c38d3c2b4e1a 100644
--- a/src/controller/java/AndroidCallbacks.h
+++ b/src/controller/java/AndroidCallbacks.h
@@ -79,5 +79,45 @@ struct ReportCallback : public app::ReadClient::Callback
     jclass mNodeStateCls  = nullptr;
 };
 
+struct ReportEventCallback : public app::ReadClient::Callback
+{
+    /** Subscription established callback can be nullptr. */
+    ReportEventCallback(jobject wrapperCallback, jobject subscriptionEstablishedCallback, jobject reportCallback,
+                        jobject resubscriptionAttemptCallback);
+    ~ReportEventCallback();
+
+    void OnReportBegin() override;
+
+    void OnReportEnd() override;
+
+    void OnEventData(const app::EventHeader & aEventHeader, TLV::TLVReader * apData, const app::StatusIB * apStatus) override;
+
+    void OnError(CHIP_ERROR aError) override;
+
+    void OnDone(app::ReadClient *) override;
+
+    void OnSubscriptionEstablished(SubscriptionId aSubscriptionId) override;
+
+    void OnResubscriptionAttempt(CHIP_ERROR aTerminationCause, uint32_t aNextResubscribeIntervalMsec) override;
+
+    /** Report errors back to Java layer. attributePath may be nullptr for general errors. */
+    void ReportError(jobject eventPath, CHIP_ERROR err);
+    void ReportError(jobject eventPath, Protocols::InteractionModel::Status status);
+    void ReportError(jobject eventPath, const char * message, ChipError::StorageType errorCode);
+
+    CHIP_ERROR CreateChipEventPath(const app::ConcreteEventPath & aPath, jobject & outObj);
+
+    app::ReadClient * mReadClient = nullptr;
+
+    app::BufferedReadCallback mBufferedReadAdapter;
+    jobject mWrapperCallbackRef                 = nullptr;
+    jobject mSubscriptionEstablishedCallbackRef = nullptr;
+    jobject mResubscriptionAttemptCallbackRef   = nullptr;
+    jobject mReportCallbackRef                  = nullptr;
+    // NodeState Java object that will be returned to the application.
+    jobject mNodeStateObj = nullptr;
+    jclass mNodeStateCls  = nullptr;
+};
+
 } // namespace Controller
 } // namespace chip
diff --git a/src/controller/java/BUILD.gn b/src/controller/java/BUILD.gn
index b808a6b36f561f..b474224304053f 100644
--- a/src/controller/java/BUILD.gn
+++ b/src/controller/java/BUILD.gn
@@ -39,6 +39,7 @@ shared_library("jni") {
     "CHIPDeviceController-JNI.cpp",
     "zap-generated/CHIPAttributeTLVValueDecoder.cpp",
     "zap-generated/CHIPClustersWrite-JNI.cpp",
+    "zap-generated/CHIPEventTLVValueDecoder.cpp",
     "zap-generated/CHIPInvokeCallbacks.cpp",
     "zap-generated/CHIPInvokeCallbacks.h",
     "zap-generated/CHIPReadCallbacks.cpp",
@@ -98,14 +99,20 @@ android_library("java") {
     "src/chip/devicecontroller/PaseVerifierParams.java",
     "src/chip/devicecontroller/ReportCallback.java",
     "src/chip/devicecontroller/ReportCallbackJni.java",
+    "src/chip/devicecontroller/ReportEventCallback.java",
+    "src/chip/devicecontroller/ReportEventCallbackJni.java",
+    "src/chip/devicecontroller/ResubscriptionAttemptCallback.java",
     "src/chip/devicecontroller/SubscriptionEstablishedCallback.java",
     "src/chip/devicecontroller/model/AttributeState.java",
     "src/chip/devicecontroller/model/ChipAttributePath.java",
+    "src/chip/devicecontroller/model/ChipEventPath.java",
     "src/chip/devicecontroller/model/ChipPathId.java",
     "src/chip/devicecontroller/model/ClusterState.java",
     "src/chip/devicecontroller/model/EndpointState.java",
+    "src/chip/devicecontroller/model/EventState.java",
     "src/chip/devicecontroller/model/NodeState.java",
     "zap-generated/chip/devicecontroller/ChipClusters.java",
+    "zap-generated/chip/devicecontroller/ChipEventStructs.java",
     "zap-generated/chip/devicecontroller/ChipIdLookup.java",
     "zap-generated/chip/devicecontroller/ChipStructs.java",
     "zap-generated/chip/devicecontroller/ClusterInfoMapping.java",
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index bed9cb146b4c56..5499fee6909a75 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -77,6 +77,8 @@ static CHIP_ERROR ParseAttributePathList(jobject attributePathList,
                                          std::vector<app::AttributePathParams> & outAttributePathParamsList);
 static CHIP_ERROR ParseAttributePath(jobject attributePath, EndpointId & outEndpointId, ClusterId & outClusterId,
                                      AttributeId & outAttributeId);
+static CHIP_ERROR ParseEventPathList(jobject eventPathList, std::vector<app::EventPathParams> & outEventPathParamsList);
+static CHIP_ERROR ParseEventPath(jobject eventPath, EndpointId & outEndpointId, ClusterId & outClusterId, EventId & outEventId);
 static CHIP_ERROR IsWildcardChipPathId(jobject chipPathId, bool & isWildcard);
 
 namespace {
@@ -938,6 +940,92 @@ JNI_METHOD(void, readPath)
     callback->mReadClient = readClient;
 }
 
+JNI_METHOD(void, subscribeToEventPath)
+(JNIEnv * env, jobject self, jlong handle, jlong callbackHandle, jlong devicePtr, jobject eventPathList, jint minInterval,
+ jint maxInterval, jboolean keepSubscriptions, jboolean isFabricFiltered)
+{
+    chip::DeviceLayer::StackLock lock;
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    DeviceProxy * device = reinterpret_cast<DeviceProxy *>(devicePtr);
+    if (device == nullptr)
+    {
+        ChipLogError(Controller, "No device found");
+        JniReferences::GetInstance().ThrowError(env, sChipDeviceControllerExceptionCls, CHIP_ERROR_INCORRECT_STATE);
+    }
+
+    std::vector<app::EventPathParams> eventPathParamsList;
+    err = ParseEventPathList(eventPathList, eventPathParamsList);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Error parsing Java event paths: %s", ErrorStr(err)));
+
+    app::ReadPrepareParams params(device->GetSecureSession().Value());
+    params.mMinIntervalFloorSeconds   = minInterval;
+    params.mMaxIntervalCeilingSeconds = maxInterval;
+    params.mpEventPathParamsList      = eventPathParamsList.data();
+    params.mEventPathParamsListSize   = eventPathParamsList.size();
+    params.mKeepSubscriptions         = (keepSubscriptions != JNI_FALSE);
+    params.mIsFabricFiltered          = (isFabricFiltered != JNI_FALSE);
+
+    auto callback = reinterpret_cast<ReportEventCallback *>(callbackHandle);
+
+    app::ReadClient * readClient =
+        Platform::New<app::ReadClient>(app::InteractionModelEngine::GetInstance(), device->GetExchangeManager(),
+                                       callback->mBufferedReadAdapter, app::ReadClient::InteractionType::Subscribe);
+
+    err = readClient->SendAutoResubscribeRequest(std::move(params));
+    if (err != CHIP_NO_ERROR)
+    {
+        chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback->mReportCallbackRef, ErrorStr(err),
+                                                                                  err);
+        delete readClient;
+        delete callback;
+        return;
+    }
+
+    callback->mReadClient = readClient;
+}
+
+JNI_METHOD(void, readEventPath)
+(JNIEnv * env, jobject self, jlong handle, jlong callbackHandle, jlong devicePtr, jobject eventPathList)
+{
+    chip::DeviceLayer::StackLock lock;
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    DeviceProxy * device = reinterpret_cast<DeviceProxy *>(devicePtr);
+    if (device == nullptr)
+    {
+        ChipLogError(Controller, "No device found");
+        JniReferences::GetInstance().ThrowError(env, sChipDeviceControllerExceptionCls, CHIP_ERROR_INCORRECT_STATE);
+    }
+
+    std::vector<app::EventPathParams> eventPathParamsList;
+
+    err = ParseEventPathList(eventPathList, eventPathParamsList);
+    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Error parsing Java event paths: %s", ErrorStr(err)));
+
+    app::ReadPrepareParams params(device->GetSecureSession().Value());
+    params.mpEventPathParamsList    = eventPathParamsList.data();
+    params.mEventPathParamsListSize = eventPathParamsList.size();
+
+    auto callback = reinterpret_cast<ReportEventCallback *>(callbackHandle);
+
+    app::ReadClient * readClient =
+        Platform::New<app::ReadClient>(app::InteractionModelEngine::GetInstance(), device->GetExchangeManager(),
+                                       callback->mBufferedReadAdapter, app::ReadClient::InteractionType::Read);
+
+    err = readClient->SendRequest(params);
+    if (err != CHIP_NO_ERROR)
+    {
+        chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback->mReportCallbackRef, ErrorStr(err),
+                                                                                  err);
+        delete readClient;
+        delete callback;
+        return;
+    }
+
+    callback->mReadClient = readClient;
+}
+
 /**
  * Takes objects in attributePathList, converts them to app:AttributePathParams, and appends them to outAttributePathParamsList.
  */
@@ -997,6 +1085,65 @@ CHIP_ERROR ParseAttributePath(jobject attributePath, EndpointId & outEndpointId,
     return CHIP_NO_ERROR;
 }
 
+/**
+ * Takes objects in eventPathList, converts them to app:EventPathParams, and appends them to outEventPathParamsList.
+ */
+CHIP_ERROR ParseEventPathList(jobject eventPathList, std::vector<app::EventPathParams> & outEventPathParamsList)
+{
+    jint listSize;
+    ReturnErrorOnFailure(JniReferences::GetInstance().GetListSize(eventPathList, listSize));
+
+    for (uint8_t i = 0; i < listSize; i++)
+    {
+        jobject eventPathItem = nullptr;
+        ReturnErrorOnFailure(JniReferences::GetInstance().GetListItem(eventPathList, i, eventPathItem));
+
+        EndpointId endpointId;
+        ClusterId clusterId;
+        EventId eventId;
+        ReturnErrorOnFailure(ParseEventPath(eventPathItem, endpointId, clusterId, eventId));
+        outEventPathParamsList.push_back(app::EventPathParams(endpointId, clusterId, eventId));
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ParseEventPath(jobject eventPath, EndpointId & outEndpointId, ClusterId & outClusterId, EventId & outEventId)
+{
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+
+    jmethodID getEndpointIdMethod = nullptr;
+    jmethodID getClusterIdMethod  = nullptr;
+    jmethodID getEventIdMethod    = nullptr;
+
+    ReturnErrorOnFailure(JniReferences::GetInstance().FindMethod(
+        env, eventPath, "getEndpointId", "()Lchip/devicecontroller/model/ChipPathId;", &getEndpointIdMethod));
+    ReturnErrorOnFailure(JniReferences::GetInstance().FindMethod(
+        env, eventPath, "getClusterId", "()Lchip/devicecontroller/model/ChipPathId;", &getClusterIdMethod));
+    ReturnErrorOnFailure(JniReferences::GetInstance().FindMethod(env, eventPath, "getEventId",
+                                                                 "()Lchip/devicecontroller/model/ChipPathId;", &getEventIdMethod));
+
+    jobject endpointIdObj = env->CallObjectMethod(eventPath, getEndpointIdMethod);
+    VerifyOrReturnError(endpointIdObj != nullptr, CHIP_ERROR_INCORRECT_STATE);
+    jobject clusterIdObj = env->CallObjectMethod(eventPath, getClusterIdMethod);
+    VerifyOrReturnError(clusterIdObj != nullptr, CHIP_ERROR_INCORRECT_STATE);
+    jobject eventIdObj = env->CallObjectMethod(eventPath, getEventIdMethod);
+    VerifyOrReturnError(eventIdObj != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    uint32_t endpointId = 0;
+    ReturnErrorOnFailure(GetChipPathIdValue(endpointIdObj, kInvalidEndpointId, endpointId));
+    uint32_t clusterId = 0;
+    ReturnErrorOnFailure(GetChipPathIdValue(clusterIdObj, kInvalidClusterId, clusterId));
+    uint32_t eventId = 0;
+    ReturnErrorOnFailure(GetChipPathIdValue(eventIdObj, kInvalidEventId, eventId));
+
+    outEndpointId = static_cast<EndpointId>(endpointId);
+    outClusterId  = static_cast<ClusterId>(clusterId);
+    outEventId    = static_cast<EventId>(eventId);
+
+    return CHIP_NO_ERROR;
+}
+
 CHIP_ERROR GetChipPathIdValue(jobject chipPathId, uint32_t wildcardValue, uint32_t & outValue)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
diff --git a/src/controller/java/CHIPEventTLVValueDecoder.h b/src/controller/java/CHIPEventTLVValueDecoder.h
new file mode 100644
index 00000000000000..963e71b86d8ce5
--- /dev/null
+++ b/src/controller/java/CHIPEventTLVValueDecoder.h
@@ -0,0 +1,30 @@
+/*
+ *
+ *    Copyright (c) 2022 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#pragma once
+
+#include <app/ConcreteEventPath.h>
+#include <jni.h>
+#include <lib/core/CHIPError.h>
+#include <lib/core/CHIPTLV.h>
+
+namespace chip {
+
+jobject DecodeEventValue(const chip::app::ConcreteEventPath & aPath, chip::TLV::TLVReader & aReader, CHIP_ERROR * aError);
+
+} // namespace chip
diff --git a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
index b9d916bc6636c4..032f373e424a81 100644
--- a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
+++ b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
@@ -22,6 +22,7 @@
 import androidx.annotation.Nullable;
 import chip.devicecontroller.GetConnectedDeviceCallbackJni.GetConnectedDeviceCallback;
 import chip.devicecontroller.model.ChipAttributePath;
+import chip.devicecontroller.model.ChipEventPath;
 import java.util.List;
 
 /** Controller to interact with the CHIP device. */
@@ -378,6 +379,58 @@ public void readPath(
     readPath(deviceControllerPtr, jniCallback.getCallbackHandle(), devicePtr, attributePaths);
   }
 
+  /** Subscribe to the given event path. */
+  public void subscribeToEventPath(
+      SubscriptionEstablishedCallback subscriptionEstablishedCallback,
+      ResubscriptionAttemptCallback resubscriptionAttemptCallback,
+      ReportEventCallback reportCallback,
+      long devicePtr,
+      List<ChipEventPath> eventPaths,
+      int minInterval,
+      int maxInterval) {
+    subscribeToEventPath(
+        subscriptionEstablishedCallback,
+        resubscriptionAttemptCallback,
+        reportCallback,
+        devicePtr,
+        eventPaths,
+        minInterval,
+        maxInterval,
+        false,
+        true);
+  }
+
+  public void subscribeToEventPath(
+      SubscriptionEstablishedCallback subscriptionEstablishedCallback,
+      ResubscriptionAttemptCallback resubscriptionAttemptCallback,
+      ReportEventCallback reportCallback,
+      long devicePtr,
+      List<ChipEventPath> eventPaths,
+      int minInterval,
+      int maxInterval,
+      boolean keepSubscriptions,
+      boolean isFabricFiltered) {
+    ReportEventCallbackJni jniCallback =
+        new ReportEventCallbackJni(
+            subscriptionEstablishedCallback, reportCallback, resubscriptionAttemptCallback);
+    subscribeToEventPath(
+        deviceControllerPtr,
+        jniCallback.getCallbackHandle(),
+        devicePtr,
+        eventPaths,
+        minInterval,
+        maxInterval,
+        keepSubscriptions,
+        isFabricFiltered);
+  }
+
+  /** Read the given event path. */
+  public void readEventPath(
+      ReportEventCallback callback, long devicePtr, List<ChipEventPath> eventPaths) {
+    ReportEventCallbackJni jniCallback = new ReportEventCallbackJni(null, callback, null);
+    readEventPath(deviceControllerPtr, jniCallback.getCallbackHandle(), devicePtr, eventPaths);
+  }
+
   /**
    * Converts a given X.509v3 certificate into a Matter certificate.
    *
@@ -420,6 +473,22 @@ public native void readPath(
       long devicePtr,
       List<ChipAttributePath> attributePaths);
 
+  private native void subscribeToEventPath(
+      long deviceControllerPtr,
+      long callbackHandle,
+      long devicePtr,
+      List<ChipEventPath> eventPaths,
+      int minInterval,
+      int maxInterval,
+      boolean keepSubscriptions,
+      boolean isFabricFiltered);
+
+  public native void readEventPath(
+      long deviceControllerPtr,
+      long callbackHandle,
+      long devicePtr,
+      List<ChipEventPath> eventPaths);
+
   private native long newDeviceController(ControllerParams params);
 
   private native void pairDevice(
diff --git a/src/controller/java/src/chip/devicecontroller/ReportCallback.java b/src/controller/java/src/chip/devicecontroller/ReportCallback.java
index 8d4859693db871..011b569472f2c2 100644
--- a/src/controller/java/src/chip/devicecontroller/ReportCallback.java
+++ b/src/controller/java/src/chip/devicecontroller/ReportCallback.java
@@ -25,4 +25,6 @@ public interface ReportCallback {
   void onError(ChipAttributePath attributePath, Exception e);
 
   void onReport(NodeState nodeState);
+
+  default void onDone() {}
 }
diff --git a/src/controller/java/src/chip/devicecontroller/ReportEventCallback.java b/src/controller/java/src/chip/devicecontroller/ReportEventCallback.java
new file mode 100644
index 00000000000000..b82a355f49c464
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/ReportEventCallback.java
@@ -0,0 +1,30 @@
+/*
+ *   Copyright (c) 2022 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package chip.devicecontroller;
+
+import chip.devicecontroller.model.ChipEventPath;
+import chip.devicecontroller.model.NodeState;
+
+/** An interface for receiving read/subscribe CHIP reports. */
+public interface ReportEventCallback {
+  void onError(ChipEventPath eventPath, Exception e);
+
+  void onReport(NodeState nodeState);
+
+  default void onDone() {}
+}
diff --git a/src/controller/java/src/chip/devicecontroller/ReportEventCallbackJni.java b/src/controller/java/src/chip/devicecontroller/ReportEventCallbackJni.java
new file mode 100644
index 00000000000000..6c05c09090c20b
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/ReportEventCallbackJni.java
@@ -0,0 +1,61 @@
+/*
+ *   Copyright (c) 2022 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package chip.devicecontroller;
+
+import androidx.annotation.Nullable;
+
+/** JNI wrapper callback class for {@link ReportCallback}. */
+public class ReportEventCallbackJni {
+  @Nullable private SubscriptionEstablishedCallback wrappedSubscriptionEstablishedCallback;
+  @Nullable private ResubscriptionAttemptCallback wrappedResubscriptionAttemptCallback;
+  private ReportEventCallback wrappedReportCallback;
+  private long callbackHandle;
+
+  public ReportEventCallbackJni(
+      @Nullable SubscriptionEstablishedCallback subscriptionEstablishedCallback,
+      ReportEventCallback reportCallback,
+      ResubscriptionAttemptCallback resubscriptionAttemptCallback) {
+    this.wrappedSubscriptionEstablishedCallback = subscriptionEstablishedCallback;
+    this.wrappedReportCallback = reportCallback;
+    this.wrappedResubscriptionAttemptCallback = resubscriptionAttemptCallback;
+    this.callbackHandle =
+        newCallback(subscriptionEstablishedCallback, reportCallback, resubscriptionAttemptCallback);
+  }
+
+  long getCallbackHandle() {
+    return callbackHandle;
+  }
+
+  private native long newCallback(
+      @Nullable SubscriptionEstablishedCallback subscriptionEstablishedCallback,
+      ReportEventCallback wrappedCallback,
+      @Nullable ResubscriptionAttemptCallback resubscriptionAttemptCallback);
+
+  private native void deleteCallback(long callbackHandle);
+
+  // TODO(#8578): Replace finalizer with PhantomReference.
+  @SuppressWarnings("deprecation")
+  protected void finalize() throws Throwable {
+    super.finalize();
+
+    if (callbackHandle != 0) {
+      deleteCallback(callbackHandle);
+      callbackHandle = 0;
+    }
+  }
+}
diff --git a/src/controller/java/src/chip/devicecontroller/ResubscriptionAttemptCallback.java b/src/controller/java/src/chip/devicecontroller/ResubscriptionAttemptCallback.java
new file mode 100644
index 00000000000000..cf029ffa54b593
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/ResubscriptionAttemptCallback.java
@@ -0,0 +1,22 @@
+/*
+ *   Copyright (c) 2022 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package chip.devicecontroller;
+
+public interface ResubscriptionAttemptCallback {
+  void onResubscriptionAttempt(int terminationCause, int nextResubscribeIntervalMsec);
+}
diff --git a/src/controller/java/src/chip/devicecontroller/model/ChipEventPath.java b/src/controller/java/src/chip/devicecontroller/model/ChipEventPath.java
new file mode 100644
index 00000000000000..56d4a6c36297e4
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/model/ChipEventPath.java
@@ -0,0 +1,77 @@
+/*
+ *   Copyright (c) 2022 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package chip.devicecontroller.model;
+
+import java.util.Locale;
+import java.util.Objects;
+
+/** An event path that should be used for requests. */
+public class ChipEventPath {
+  private ChipPathId endpointId, clusterId, eventId;
+
+  private ChipEventPath(ChipPathId endpointId, ChipPathId clusterId, ChipPathId eventId) {
+    this.endpointId = endpointId;
+    this.clusterId = clusterId;
+    this.eventId = eventId;
+  }
+
+  public ChipPathId getEndpointId() {
+    return endpointId;
+  }
+
+  public ChipPathId getClusterId() {
+    return clusterId;
+  }
+
+  public ChipPathId getEventId() {
+    return eventId;
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    if (object instanceof ChipEventPath) {
+      ChipEventPath that = (ChipEventPath) object;
+      return Objects.equals(this.endpointId, that.endpointId)
+          && Objects.equals(this.clusterId, that.clusterId)
+          && Objects.equals(this.eventId, that.eventId);
+    }
+    return false;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(endpointId, clusterId, eventId);
+  }
+
+  @Override
+  public String toString() {
+    return String.format(
+        Locale.ENGLISH, "Endpoint %s, cluster %s, event %s", endpointId, clusterId, eventId);
+  }
+
+  public static ChipEventPath newInstance(
+      ChipPathId endpointId, ChipPathId clusterId, ChipPathId eventId) {
+    return new ChipEventPath(endpointId, clusterId, eventId);
+  }
+
+  /** Create a new {@link ChipEventPath} with only concrete ids. */
+  public static ChipEventPath newInstance(long endpointId, long clusterId, long eventId) {
+    return new ChipEventPath(
+        ChipPathId.forId(endpointId), ChipPathId.forId(clusterId), ChipPathId.forId(eventId));
+  }
+}
diff --git a/src/controller/java/src/chip/devicecontroller/model/ClusterState.java b/src/controller/java/src/chip/devicecontroller/model/ClusterState.java
index ee37b452dfcc55..149d3b1ca97662 100644
--- a/src/controller/java/src/chip/devicecontroller/model/ClusterState.java
+++ b/src/controller/java/src/chip/devicecontroller/model/ClusterState.java
@@ -23,25 +23,41 @@
 /** Class for tracking CHIP cluster state in a hierarchical manner. */
 public final class ClusterState {
   private Map<Long, AttributeState> attributes;
+  private Map<Long, EventState> events;
 
-  public ClusterState(Map<Long, AttributeState> attributes) {
+  public ClusterState(Map<Long, AttributeState> attributes, Map<Long, EventState> events) {
     this.attributes = attributes;
+    this.events = events;
   }
 
   public Map<Long, AttributeState> getAttributeStates() {
     return attributes;
   }
 
+  public Map<Long, EventState> getEventStates() {
+    return events;
+  }
+
   /**
-   * Convenience utility for getting an {@code ClusterState}.
+   * Convenience utility for getting an {@code AttributeState}.
    *
-   * @return the {@code ClusterState} for the specified id, or null if not found.
+   * @return the {@code AttributeState} for the specified id, or null if not found.
    */
   @Nullable
   public AttributeState getAttributeState(long attributeId) {
     return attributes.get(attributeId);
   }
 
+  /**
+   * Convenience utility for getting an {@code EventState}.
+   *
+   * @return the {@code EventState} for the specified id, or null if not found.
+   */
+  @Nullable
+  public EventState getEventState(long eventId) {
+    return events.get(eventId);
+  }
+
   @Override
   public String toString() {
     StringBuilder builder = new StringBuilder();
@@ -54,6 +70,14 @@ public String toString() {
               attributeState.getValue() == null ? "null" : attributeState.getValue().toString());
           builder.append("\n");
         });
+    events.forEach(
+        (eventId, eventState) -> {
+          builder.append("Event ");
+          builder.append(eventId);
+          builder.append(": ");
+          builder.append(eventState.getValue() == null ? "null" : eventState.getValue().toString());
+          builder.append("\n");
+        });
     return builder.toString();
   }
 }
diff --git a/src/controller/java/src/chip/devicecontroller/model/EventState.java b/src/controller/java/src/chip/devicecontroller/model/EventState.java
new file mode 100644
index 00000000000000..34202377d2d25c
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/model/EventState.java
@@ -0,0 +1,61 @@
+/*
+ *   Copyright (c) 2022 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package chip.devicecontroller.model;
+
+import android.util.Log;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Represents the reported value of an attribute in object form, TLV and JSON. */
+public final class EventState {
+  private static final String TAG = "EventState";
+
+  private Object valueObject;
+  private byte[] tlv;
+  private JSONObject json;
+
+  public EventState(Object valueObject, byte[] tlv, String jsonString) {
+    this.valueObject = valueObject;
+    this.tlv = tlv;
+    try {
+      this.json = new JSONObject(jsonString);
+    } catch (JSONException ex) {
+      Log.e(TAG, "Error parsing JSON string", ex);
+    }
+  }
+
+  public Object getValue() {
+    return valueObject;
+  }
+
+  /**
+   * Return a byte array containing the TLV for an attribute, wrapped within an anonymous TLV tag.
+   */
+  public byte[] getTlv() {
+    return tlv;
+  }
+
+  public JSONObject getJson() {
+    return json;
+  }
+
+  @Override
+  public String toString() {
+    return valueObject.toString();
+  }
+}
diff --git a/src/controller/java/src/chip/devicecontroller/model/NodeState.java b/src/controller/java/src/chip/devicecontroller/model/NodeState.java
index a4e6585c26e4b2..d2155aa1ff9b23 100644
--- a/src/controller/java/src/chip/devicecontroller/model/NodeState.java
+++ b/src/controller/java/src/chip/devicecontroller/model/NodeState.java
@@ -44,7 +44,7 @@ private void addAttribute(
 
     ClusterState clusterState = endpointState.getClusterState(clusterId);
     if (clusterState == null) {
-      clusterState = new ClusterState(new HashMap<>());
+      clusterState = new ClusterState(new HashMap<>(), new HashMap<>());
       endpointState.getClusterStates().put(clusterId, clusterState);
     }
 
@@ -52,6 +52,23 @@ private void addAttribute(
     clusterState.getAttributeStates().put(attributeId, attributeStateToAdd);
   }
 
+  private void addEvent(int endpointId, long clusterId, long eventId, EventState eventStateToAdd) {
+    EndpointState endpointState = getEndpointState(endpointId);
+    if (endpointState == null) {
+      endpointState = new EndpointState(new HashMap<>());
+      getEndpointStates().put(endpointId, endpointState);
+    }
+
+    ClusterState clusterState = endpointState.getClusterState(clusterId);
+    if (clusterState == null) {
+      clusterState = new ClusterState(new HashMap<>(), new HashMap<>());
+      endpointState.getClusterStates().put(clusterId, clusterState);
+    }
+
+    // This will overwrite previous events.
+    clusterState.getEventStates().put(eventId, eventStateToAdd);
+  }
+
   @Override
   public String toString() {
     StringBuilder builder = new StringBuilder();
diff --git a/src/controller/java/templates/CHIPEventTLVValueDecoder-src.zapt b/src/controller/java/templates/CHIPEventTLVValueDecoder-src.zapt
new file mode 100644
index 00000000000000..7f4936670cdb1d
--- /dev/null
+++ b/src/controller/java/templates/CHIPEventTLVValueDecoder-src.zapt
@@ -0,0 +1,93 @@
+/*
+ *
+ *    Copyright (c) 2022 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include <controller/java/CHIPAttributeTLVValueDecoder.h>
+
+#include <app/data-model/Decode.h>
+#include <app/data-model/DecodableList.h>
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app-common/zap-generated/ids/Events.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <jni.h>
+#include <lib/support/JniReferences.h>
+#include <lib/support/JniTypeWrappers.h>
+#include <lib/support/TypeTraits.h>
+
+namespace chip {
+
+jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & aReader, CHIP_ERROR * aError)
+{
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    
+    switch (aPath.mClusterId)
+    {
+        {{#chip_client_clusters}}
+        case app::Clusters::{{asUpperCamelCase name}}::Id: {
+            using namespace app::Clusters::{{asUpperCamelCase name}};
+            switch (aPath.mEventId)
+            {
+                {{#zcl_events}}
+                case Events::{{asUpperCamelCase name}}::Id: {
+                    Events::{{asUpperCamelCase name}}::DecodableType cppValue;
+                    *aError = app::DataModel::Decode(aReader, cppValue);
+                    if (*aError != CHIP_NO_ERROR)
+                    {
+                        return nullptr;
+                    }
+                    {{#zcl_event_fields}}
+                    {{>decode_value target=(concat "value_" (asLowerCamelCase name)) source=(concat "cppValue." (asLowerCamelCase name)) cluster=(asUpperCamelCase parent.parent.name) depth=0 earlyReturn="nullptr"}}
+
+                    {{/zcl_event_fields}}
+                    jclass {{asLowerCamelCase name}}StructClass;
+                    err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipEventStructs${{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Event", {{asLowerCamelCase name}}StructClass);
+                    if (err != CHIP_NO_ERROR) {
+                        ChipLogError(Zcl, "Could not find class ChipEventStructs${{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Event");
+                        return nullptr;
+                    }
+                    jmethodID {{asLowerCamelCase name}}StructCtor = env->GetMethodID({{asLowerCamelCase name}}StructClass, "<init>"
+                        , "({{#zcl_event_fields}}{{asJniSignature type null (asUpperCamelCase parent.parent.name) true}}{{/zcl_event_fields}})V");
+                    if ({{asLowerCamelCase name}}StructCtor == nullptr) {
+                        ChipLogError(Zcl, "Could not find ChipEventStructs${{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Event constructor");
+                        return nullptr;
+                    }
+
+                    jobject value = env->NewObject({{asLowerCamelCase name}}StructClass, {{asLowerCamelCase name}}StructCtor
+                    {{#zcl_event_fields}}
+                    , value_{{asLowerCamelCase name}}
+                    {{/zcl_event_fields}}
+                    );
+
+                    return value;
+                }
+                {{/zcl_events}}
+                default:
+                    *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+                    break;
+            }
+            break;
+        }
+        {{/chip_client_clusters}}
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+    } 
+    return nullptr;
+}
+
+} // namespace chip
diff --git a/src/controller/java/templates/ChipEventStructs-java.zapt b/src/controller/java/templates/ChipEventStructs-java.zapt
new file mode 100644
index 00000000000000..63f20476386cc7
--- /dev/null
+++ b/src/controller/java/templates/ChipEventStructs-java.zapt
@@ -0,0 +1,59 @@
+{{> header}}
+package chip.devicecontroller;
+
+{{#if (chip_has_client_clusters)}}
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Optional;
+{{/if}}
+
+{{! TODO: Use AutoValue for inner classes. }}
+public class ChipEventStructs {
+{{#if (chip_has_client_clusters)}}
+{{#chip_client_clusters}}
+{{#zcl_events}}
+public static class {{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Event {
+{{#zcl_event_fields}}
+{{! TODO: This uses the vague type List<Object> for some list types. }}
+public {{asJavaType type null parent.parent.name includeAnnotations=true}} {{asLowerCamelCase (asSymbol name)}};
+{{/zcl_event_fields}}
+
+  public {{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Event(
+  {{#zcl_event_fields}}
+    {{#not_first}}, {{/not_first}}{{asJavaType type null parent.parent.name includeAnnotations=true}} {{asLowerCamelCase (asSymbol name)}}
+  {{/zcl_event_fields}}) {
+    {{#zcl_event_fields}}
+    this.{{asLowerCamelCase (asSymbol name)}} = {{asLowerCamelCase (asSymbol name)}};
+    {{/zcl_event_fields}}
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder output = new StringBuilder();
+    output.append("{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Event {\n");
+    {{#zcl_event_fields}}
+    {{! TODO: Print more descriptive types for optional, nullable, array, and struct. }}
+    output.append("\t{{asLowerCamelCase name}}: ");
+    {{#if isArray}}
+    output.append({{asLowerCamelCase name}});
+    {{else if (isOctetString type)}}
+    {{#if isOptional}}
+    output.append({{asLowerCamelCase name}}.isPresent() ? Arrays.toString({{asLowerCamelCase name}}.get()) : "");
+    {{else}}
+    output.append(Arrays.toString({{asLowerCamelCase name}}));
+    {{/if}}
+    {{else}}
+    output.append({{asLowerCamelCase name}});
+    {{/if}}
+    output.append("\n");
+    {{/zcl_event_fields}}
+    output.append("}\n");
+    return output.toString();
+  }
+}
+
+{{/zcl_events}}
+{{/chip_client_clusters}}
+{{/if}}
+}
\ No newline at end of file
diff --git a/src/controller/java/templates/ChipIdLookup-java.zapt b/src/controller/java/templates/ChipIdLookup-java.zapt
index fc9e21fb7ca59e..10dd829a18c611 100644
--- a/src/controller/java/templates/ChipIdLookup-java.zapt
+++ b/src/controller/java/templates/ChipIdLookup-java.zapt
@@ -34,5 +34,23 @@ public final class ChipIdLookup {
     {{/chip_client_clusters}}
     return "";
   }
+
+  /**
+   * Translates cluster ID and event ID to an attribute name in upper camel case.
+   * If no matching IDs are found, returns an empty string.
+   */
+  public static String eventIdToName(long clusterId, long eventId) {
+    {{#chip_client_clusters}}
+    if (clusterId == {{code}}L) {
+      {{#chip_server_cluster_events}}
+      if (eventId == {{code}}L) {
+        return "{{asUpperCamelCase name}}";
+      }
+      {{/chip_server_cluster_events}}
+      return "";
+    }
+    {{/chip_client_clusters}}
+    return "";
+  }
 }
 {{/if}}
\ No newline at end of file
diff --git a/src/controller/java/templates/partials/decode_value.zapt b/src/controller/java/templates/partials/decode_value.zapt
index bc2b8cb4e2b2a1..a6fa4ab3cd2e3c 100644
--- a/src/controller/java/templates/partials/decode_value.zapt
+++ b/src/controller/java/templates/partials/decode_value.zapt
@@ -31,20 +31,20 @@ if ({{source}}.IsNull()) {
       {{>decode_value target=(concat ../target "_" (asLowerCamelCase label)) source=(concat ../source "." (asLowerCamelCase label)) cluster=../cluster depth=(incrementDepth ../depth) omitDeclaration=false earlyReturn=../earlyReturn}}
     {{/zcl_struct_items_by_struct_name}}
 
-    jclass {{asLowerCamelCase type}}StructClass;
-    err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs${{cluster}}Cluster{{asUpperCamelCase type}}", {{asLowerCamelCase type}}StructClass);
+    jclass {{asLowerCamelCase type}}StructClass_{{depth}};
+    err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs${{cluster}}Cluster{{asUpperCamelCase type}}", {{asLowerCamelCase type}}StructClass_{{depth}});
     if (err != CHIP_NO_ERROR) {
       ChipLogError(Zcl, "Could not find class ChipStructs${{cluster}}Cluster{{asUpperCamelCase type}}");
       return {{earlyReturn}};
     }
-    jmethodID {{asLowerCamelCase type}}StructCtor = env->GetMethodID({{asLowerCamelCase type}}StructClass, "<init>"
+    jmethodID {{asLowerCamelCase type}}StructCtor_{{depth}} = env->GetMethodID({{asLowerCamelCase type}}StructClass_{{depth}}, "<init>"
         , "({{#zcl_struct_items_by_struct_name type}}{{asJniSignature type null ../cluster true}}{{/zcl_struct_items_by_struct_name}})V");
-    if ({{asLowerCamelCase type}}StructCtor == nullptr) {
+    if ({{asLowerCamelCase type}}StructCtor_{{depth}} == nullptr) {
       ChipLogError(Zcl, "Could not find ChipStructs${{cluster}}Cluster{{asUpperCamelCase type}} constructor");
       return {{earlyReturn}};
     }
 
-    {{target}} = env->NewObject({{asLowerCamelCase type}}StructClass, {{asLowerCamelCase type}}StructCtor
+    {{target}} = env->NewObject({{asLowerCamelCase type}}StructClass_{{depth}}, {{asLowerCamelCase type}}StructCtor_{{depth}}
       {{#zcl_struct_items_by_struct_name type}}
       , {{../target}}_{{asLowerCamelCase label}}
       {{/zcl_struct_items_by_struct_name}}
diff --git a/src/controller/java/templates/templates.json b/src/controller/java/templates/templates.json
index 8c513acad7370e..7b1521f0865053 100644
--- a/src/controller/java/templates/templates.json
+++ b/src/controller/java/templates/templates.json
@@ -39,6 +39,11 @@
             "name": "CHIP structs for Java",
             "output": "src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java"
         },
+        {
+            "path": "ChipEventStructs-java.zapt",
+            "name": "CHIP Event structs for Java",
+            "output": "src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java"
+        },
         {
             "path": "CHIPInvokeCallbacks.zapt",
             "name": "CHIP cluster invoke callbacks for Java (native code)",
@@ -74,6 +79,11 @@
             "name": "CHIP cluster attribute decoder for Java (native code)",
             "output": "src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp"
         },
+        {
+            "path": "CHIPEventTLVValueDecoder-src.zapt",
+            "name": "CHIP cluster event decoder for Java (native code)",
+            "output": "src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp"
+        },
         {
             "path": "ChipClusters-java.zapt",
             "name": "CHIP ZCL API for Java",
diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
index 4d373322db5ced..8030b121f12785 100644
--- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
+++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
@@ -1375,24 +1375,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                                newElement_0_revisionCtorSignature.c_str(),
                                                                                entry_0.revision, newElement_0_revision);
 
-                jclass deviceTypeStructClass;
+                jclass deviceTypeStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$DescriptorClusterDeviceType", deviceTypeStructClass);
+                    env, "chip/devicecontroller/ChipStructs$DescriptorClusterDeviceType", deviceTypeStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$DescriptorClusterDeviceType");
                     return nullptr;
                 }
-                jmethodID deviceTypeStructCtor =
-                    env->GetMethodID(deviceTypeStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;)V");
-                if (deviceTypeStructCtor == nullptr)
+                jmethodID deviceTypeStructCtor_1 =
+                    env->GetMethodID(deviceTypeStructClass_1, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;)V");
+                if (deviceTypeStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$DescriptorClusterDeviceType constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(deviceTypeStructClass, deviceTypeStructCtor, newElement_0_type, newElement_0_revision);
+                    env->NewObject(deviceTypeStructClass_1, deviceTypeStructCtor_1, newElement_0_type, newElement_0_revision);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -1666,25 +1666,25 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass targetStructStructClass;
+                jclass targetStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$BindingClusterTargetStruct", targetStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$BindingClusterTargetStruct", targetStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$BindingClusterTargetStruct");
                     return nullptr;
                 }
-                jmethodID targetStructStructCtor = env->GetMethodID(
-                    targetStructStructClass, "<init>",
+                jmethodID targetStructStructCtor_1 = env->GetMethodID(
+                    targetStructStructClass_1, "<init>",
                     "(Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/lang/Integer;)V");
-                if (targetStructStructCtor == nullptr)
+                if (targetStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$BindingClusterTargetStruct constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(targetStructStructClass, targetStructStructCtor, newElement_0_node, newElement_0_group,
+                    env->NewObject(targetStructStructClass_1, targetStructStructCtor_1, newElement_0_node, newElement_0_group,
                                    newElement_0_endpoint, newElement_0_cluster, newElement_0_fabricIndex);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -1905,23 +1905,23 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                 entry_3.deviceType.Value(), newElement_3_deviceType);
                         }
 
-                        jclass targetStructClass;
+                        jclass targetStructClass_4;
                         err = chip::JniReferences::GetInstance().GetClassRef(
-                            env, "chip/devicecontroller/ChipStructs$AccessControlClusterTarget", targetStructClass);
+                            env, "chip/devicecontroller/ChipStructs$AccessControlClusterTarget", targetStructClass_4);
                         if (err != CHIP_NO_ERROR)
                         {
                             ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterTarget");
                             return nullptr;
                         }
-                        jmethodID targetStructCtor =
-                            env->GetMethodID(targetStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V");
-                        if (targetStructCtor == nullptr)
+                        jmethodID targetStructCtor_4 = env->GetMethodID(targetStructClass_4, "<init>",
+                                                                        "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V");
+                        if (targetStructCtor_4 == nullptr)
                         {
                             ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterTarget constructor");
                             return nullptr;
                         }
 
-                        newElement_3 = env->NewObject(targetStructClass, targetStructCtor, newElement_3_cluster,
+                        newElement_3 = env->NewObject(targetStructClass_4, targetStructCtor_4, newElement_3_cluster,
                                                       newElement_3_endpoint, newElement_3_deviceType);
                         chip::JniReferences::GetInstance().AddToList(newElement_0_targets, newElement_3);
                     }
@@ -1933,25 +1933,26 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass accessControlEntryStructClass;
+                jclass accessControlEntryStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterAccessControlEntry", accessControlEntryStructClass);
+                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterAccessControlEntry",
+                    accessControlEntryStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterAccessControlEntry");
                     return nullptr;
                 }
-                jmethodID accessControlEntryStructCtor = env->GetMethodID(
-                    accessControlEntryStructClass, "<init>",
+                jmethodID accessControlEntryStructCtor_1 = env->GetMethodID(
+                    accessControlEntryStructClass_1, "<init>",
                     "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/ArrayList;Ljava/util/ArrayList;Ljava/lang/Integer;)V");
-                if (accessControlEntryStructCtor == nullptr)
+                if (accessControlEntryStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterAccessControlEntry constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(accessControlEntryStructClass, accessControlEntryStructCtor, newElement_0_privilege,
+                    env->NewObject(accessControlEntryStructClass_1, accessControlEntryStructCtor_1, newElement_0_privilege,
                                    newElement_0_authMode, newElement_0_subjects, newElement_0_targets, newElement_0_fabricIndex);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -1985,23 +1986,23 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass extensionEntryStructClass;
+                jclass extensionEntryStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterExtensionEntry", extensionEntryStructClass);
+                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterExtensionEntry", extensionEntryStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterExtensionEntry");
                     return nullptr;
                 }
-                jmethodID extensionEntryStructCtor =
-                    env->GetMethodID(extensionEntryStructClass, "<init>", "([BLjava/lang/Integer;)V");
-                if (extensionEntryStructCtor == nullptr)
+                jmethodID extensionEntryStructCtor_1 =
+                    env->GetMethodID(extensionEntryStructClass_1, "<init>", "([BLjava/lang/Integer;)V");
+                if (extensionEntryStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterExtensionEntry constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(extensionEntryStructClass, extensionEntryStructCtor, newElement_0_data,
+                newElement_0 = env->NewObject(extensionEntryStructClass_1, extensionEntryStructCtor_1, newElement_0_data,
                                               newElement_0_fabricIndex);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -2213,25 +2214,25 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                     newElement_0_statusClassName.c_str(), newElement_0_statusCtorSignature.c_str(),
                     static_cast<uint8_t>(entry_0.status), newElement_0_status);
 
-                jclass actionStructStructClass;
+                jclass actionStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$BridgedActionsClusterActionStruct", actionStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$BridgedActionsClusterActionStruct", actionStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$BridgedActionsClusterActionStruct");
                     return nullptr;
                 }
-                jmethodID actionStructStructCtor =
-                    env->GetMethodID(actionStructStructClass, "<init>",
+                jmethodID actionStructStructCtor_1 =
+                    env->GetMethodID(actionStructStructClass_1, "<init>",
                                      "(Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/"
                                      "Integer;Ljava/lang/Integer;)V");
-                if (actionStructStructCtor == nullptr)
+                if (actionStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$BridgedActionsClusterActionStruct constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(actionStructStructClass, actionStructStructCtor, newElement_0_actionID,
+                newElement_0 = env->NewObject(actionStructStructClass_1, actionStructStructCtor_1, newElement_0_actionID,
                                               newElement_0_name, newElement_0_type, newElement_0_endpointListID,
                                               newElement_0_supportedCommands, newElement_0_status);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
@@ -2283,26 +2284,26 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                     chip::JniReferences::GetInstance().AddToList(newElement_0_endpoints, newElement_2);
                 }
 
-                jclass endpointListStructStructClass;
+                jclass endpointListStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$BridgedActionsClusterEndpointListStruct",
-                    endpointListStructStructClass);
+                    endpointListStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$BridgedActionsClusterEndpointListStruct");
                     return nullptr;
                 }
-                jmethodID endpointListStructStructCtor =
-                    env->GetMethodID(endpointListStructStructClass, "<init>",
+                jmethodID endpointListStructStructCtor_1 =
+                    env->GetMethodID(endpointListStructStructClass_1, "<init>",
                                      "(Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/ArrayList;)V");
-                if (endpointListStructStructCtor == nullptr)
+                if (endpointListStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$BridgedActionsClusterEndpointListStruct constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(endpointListStructStructClass, endpointListStructStructCtor, newElement_0_endpointListID,
+                    env->NewObject(endpointListStructStructClass_1, endpointListStructStructCtor_1, newElement_0_endpointListID,
                                    newElement_0_name, newElement_0_type, newElement_0_endpoints);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -2703,24 +2704,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 value_subscriptionsPerFabricClassName.c_str(), value_subscriptionsPerFabricCtorSignature.c_str(),
                 cppValue.subscriptionsPerFabric, value_subscriptionsPerFabric);
 
-            jclass capabilityMinimaStructStructClass;
+            jclass capabilityMinimaStructStructClass_0;
             err = chip::JniReferences::GetInstance().GetClassRef(
-                env, "chip/devicecontroller/ChipStructs$BasicClusterCapabilityMinimaStruct", capabilityMinimaStructStructClass);
+                env, "chip/devicecontroller/ChipStructs$BasicClusterCapabilityMinimaStruct", capabilityMinimaStructStructClass_0);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$BasicClusterCapabilityMinimaStruct");
                 return nullptr;
             }
-            jmethodID capabilityMinimaStructStructCtor =
-                env->GetMethodID(capabilityMinimaStructStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
-            if (capabilityMinimaStructStructCtor == nullptr)
+            jmethodID capabilityMinimaStructStructCtor_0 =
+                env->GetMethodID(capabilityMinimaStructStructClass_0, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+            if (capabilityMinimaStructStructCtor_0 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$BasicClusterCapabilityMinimaStruct constructor");
                 return nullptr;
             }
 
-            value = env->NewObject(capabilityMinimaStructStructClass, capabilityMinimaStructStructCtor, value_caseSessionsPerFabric,
-                                   value_subscriptionsPerFabric);
+            value = env->NewObject(capabilityMinimaStructStructClass_0, capabilityMinimaStructStructCtor_0,
+                                   value_caseSessionsPerFabric, value_subscriptionsPerFabric);
             return value;
         }
         case Attributes::GeneratedCommandList::Id: {
@@ -2934,25 +2935,25 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass providerLocationStructClass;
+                jclass providerLocationStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$OtaSoftwareUpdateRequestorClusterProviderLocation",
-                    providerLocationStructClass);
+                    providerLocationStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$OtaSoftwareUpdateRequestorClusterProviderLocation");
                     return nullptr;
                 }
-                jmethodID providerLocationStructCtor = env->GetMethodID(
-                    providerLocationStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;)V");
-                if (providerLocationStructCtor == nullptr)
+                jmethodID providerLocationStructCtor_1 = env->GetMethodID(
+                    providerLocationStructClass_1, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;)V");
+                if (providerLocationStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$OtaSoftwareUpdateRequestorClusterProviderLocation constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(providerLocationStructClass, providerLocationStructCtor, newElement_0_providerNodeID,
-                                              newElement_0_endpoint, newElement_0_fabricIndex);
+                newElement_0 = env->NewObject(providerLocationStructClass_1, providerLocationStructCtor_1,
+                                              newElement_0_providerNodeID, newElement_0_endpoint, newElement_0_fabricIndex);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -4180,24 +4181,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 value_maxCumulativeFailsafeSecondsClassName.c_str(), value_maxCumulativeFailsafeSecondsCtorSignature.c_str(),
                 cppValue.maxCumulativeFailsafeSeconds, value_maxCumulativeFailsafeSeconds);
 
-            jclass basicCommissioningInfoStructClass;
+            jclass basicCommissioningInfoStructClass_0;
             err = chip::JniReferences::GetInstance().GetClassRef(
                 env, "chip/devicecontroller/ChipStructs$GeneralCommissioningClusterBasicCommissioningInfo",
-                basicCommissioningInfoStructClass);
+                basicCommissioningInfoStructClass_0);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$GeneralCommissioningClusterBasicCommissioningInfo");
                 return nullptr;
             }
-            jmethodID basicCommissioningInfoStructCtor =
-                env->GetMethodID(basicCommissioningInfoStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
-            if (basicCommissioningInfoStructCtor == nullptr)
+            jmethodID basicCommissioningInfoStructCtor_0 =
+                env->GetMethodID(basicCommissioningInfoStructClass_0, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+            if (basicCommissioningInfoStructCtor_0 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$GeneralCommissioningClusterBasicCommissioningInfo constructor");
                 return nullptr;
             }
 
-            value = env->NewObject(basicCommissioningInfoStructClass, basicCommissioningInfoStructCtor,
+            value = env->NewObject(basicCommissioningInfoStructClass_0, basicCommissioningInfoStructCtor_0,
                                    value_failSafeExpiryLengthSeconds, value_maxCumulativeFailsafeSeconds);
             return value;
         }
@@ -4401,23 +4402,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                            newElement_0_connectedCtorSignature.c_str(),
                                                                            entry_0.connected, newElement_0_connected);
 
-                jclass networkInfoStructClass;
+                jclass networkInfoStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$NetworkCommissioningClusterNetworkInfo", networkInfoStructClass);
+                    env, "chip/devicecontroller/ChipStructs$NetworkCommissioningClusterNetworkInfo", networkInfoStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$NetworkCommissioningClusterNetworkInfo");
                     return nullptr;
                 }
-                jmethodID networkInfoStructCtor = env->GetMethodID(networkInfoStructClass, "<init>", "([BLjava/lang/Boolean;)V");
-                if (networkInfoStructCtor == nullptr)
+                jmethodID networkInfoStructCtor_1 =
+                    env->GetMethodID(networkInfoStructClass_1, "<init>", "([BLjava/lang/Boolean;)V");
+                if (networkInfoStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$NetworkCommissioningClusterNetworkInfo constructor");
                     return nullptr;
                 }
 
-                newElement_0 =
-                    env->NewObject(networkInfoStructClass, networkInfoStructCtor, newElement_0_networkID, newElement_0_connected);
+                newElement_0 = env->NewObject(networkInfoStructClass_1, networkInfoStructCtor_1, newElement_0_networkID,
+                                              newElement_0_connected);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -4827,29 +4829,30 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                     newElement_0_typeClassName.c_str(), newElement_0_typeCtorSignature.c_str(), static_cast<uint8_t>(entry_0.type),
                     newElement_0_type);
 
-                jclass networkInterfaceTypeStructClass;
+                jclass networkInterfaceTypeStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$GeneralDiagnosticsClusterNetworkInterfaceType",
-                    networkInterfaceTypeStructClass);
+                    networkInterfaceTypeStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$GeneralDiagnosticsClusterNetworkInterfaceType");
                     return nullptr;
                 }
-                jmethodID networkInterfaceTypeStructCtor =
-                    env->GetMethodID(networkInterfaceTypeStructClass, "<init>",
+                jmethodID networkInterfaceTypeStructCtor_1 =
+                    env->GetMethodID(networkInterfaceTypeStructClass_1, "<init>",
                                      "(Ljava/lang/String;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;[BLjava/util/"
                                      "ArrayList;Ljava/util/ArrayList;Ljava/lang/Integer;)V");
-                if (networkInterfaceTypeStructCtor == nullptr)
+                if (networkInterfaceTypeStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$GeneralDiagnosticsClusterNetworkInterfaceType constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(networkInterfaceTypeStructClass, networkInterfaceTypeStructCtor, newElement_0_name,
-                                              newElement_0_isOperational, newElement_0_offPremiseServicesReachableIPv4,
-                                              newElement_0_offPremiseServicesReachableIPv6, newElement_0_hardwareAddress,
-                                              newElement_0_IPv4Addresses, newElement_0_IPv6Addresses, newElement_0_type);
+                newElement_0 =
+                    env->NewObject(networkInterfaceTypeStructClass_1, networkInterfaceTypeStructCtor_1, newElement_0_name,
+                                   newElement_0_isOperational, newElement_0_offPremiseServicesReachableIPv4,
+                                   newElement_0_offPremiseServicesReachableIPv6, newElement_0_hardwareAddress,
+                                   newElement_0_IPv4Addresses, newElement_0_IPv6Addresses, newElement_0_type);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -5197,25 +5200,26 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                     chip::JniReferences::GetInstance().CreateOptional(newElement_0_stackSizeInsideOptional, newElement_0_stackSize);
                 }
 
-                jclass threadMetricsStructClass;
+                jclass threadMetricsStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$SoftwareDiagnosticsClusterThreadMetrics", threadMetricsStructClass);
+                    env, "chip/devicecontroller/ChipStructs$SoftwareDiagnosticsClusterThreadMetrics", threadMetricsStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$SoftwareDiagnosticsClusterThreadMetrics");
                     return nullptr;
                 }
-                jmethodID threadMetricsStructCtor = env->GetMethodID(
-                    threadMetricsStructClass, "<init>",
+                jmethodID threadMetricsStructCtor_1 = env->GetMethodID(
+                    threadMetricsStructClass_1, "<init>",
                     "(Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V");
-                if (threadMetricsStructCtor == nullptr)
+                if (threadMetricsStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$SoftwareDiagnosticsClusterThreadMetrics constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(threadMetricsStructClass, threadMetricsStructCtor, newElement_0_id, newElement_0_name,
-                                              newElement_0_stackFreeCurrent, newElement_0_stackFreeMinimum, newElement_0_stackSize);
+                newElement_0 =
+                    env->NewObject(threadMetricsStructClass_1, threadMetricsStructCtor_1, newElement_0_id, newElement_0_name,
+                                   newElement_0_stackFreeCurrent, newElement_0_stackFreeMinimum, newElement_0_stackSize);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -5634,28 +5638,28 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                            newElement_0_isChildCtorSignature.c_str(),
                                                                            entry_0.isChild, newElement_0_isChild);
 
-                jclass neighborTableStructClass;
+                jclass neighborTableStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterNeighborTable",
-                    neighborTableStructClass);
+                    neighborTableStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ThreadNetworkDiagnosticsClusterNeighborTable");
                     return nullptr;
                 }
-                jmethodID neighborTableStructCtor =
-                    env->GetMethodID(neighborTableStructClass, "<init>",
+                jmethodID neighborTableStructCtor_1 =
+                    env->GetMethodID(neighborTableStructClass_1, "<init>",
                                      "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Long;Ljava/"
                                      "lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/"
                                      "Integer;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;)V");
-                if (neighborTableStructCtor == nullptr)
+                if (neighborTableStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ThreadNetworkDiagnosticsClusterNeighborTable constructor");
                     return nullptr;
                 }
 
                 newElement_0 = env->NewObject(
-                    neighborTableStructClass, neighborTableStructCtor, newElement_0_extAddress, newElement_0_age,
+                    neighborTableStructClass_1, neighborTableStructCtor_1, newElement_0_extAddress, newElement_0_age,
                     newElement_0_rloc16, newElement_0_linkFrameCounter, newElement_0_mleFrameCounter, newElement_0_lqi,
                     newElement_0_averageRssi, newElement_0_lastRssi, newElement_0_frameErrorRate, newElement_0_messageErrorRate,
                     newElement_0_rxOnWhenIdle, newElement_0_fullThreadDevice, newElement_0_fullNetworkData, newElement_0_isChild);
@@ -5739,26 +5743,26 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                            newElement_0_linkEstablishedCtorSignature.c_str(),
                                                                            entry_0.linkEstablished, newElement_0_linkEstablished);
 
-                jclass routeTableStructClass;
+                jclass routeTableStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterRouteTable", routeTableStructClass);
+                    env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterRouteTable", routeTableStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ThreadNetworkDiagnosticsClusterRouteTable");
                     return nullptr;
                 }
-                jmethodID routeTableStructCtor = env->GetMethodID(
-                    routeTableStructClass, "<init>",
+                jmethodID routeTableStructCtor_1 = env->GetMethodID(
+                    routeTableStructClass_1, "<init>",
                     "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/"
                     "Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Boolean;)V");
-                if (routeTableStructCtor == nullptr)
+                if (routeTableStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ThreadNetworkDiagnosticsClusterRouteTable constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(routeTableStructClass, routeTableStructCtor, newElement_0_extAddress, newElement_0_rloc16,
+                    env->NewObject(routeTableStructClass_1, routeTableStructCtor_1, newElement_0_extAddress, newElement_0_rloc16,
                                    newElement_0_routerId, newElement_0_nextHop, newElement_0_pathCost, newElement_0_LQIIn,
                                    newElement_0_LQIOut, newElement_0_age, newElement_0_allocated, newElement_0_linkEstablished);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
@@ -6598,24 +6602,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
                     value_flagsClassName.c_str(), value_flagsCtorSignature.c_str(), cppValue.Value().flags, value_flags);
 
-                jclass securityPolicyStructClass;
+                jclass securityPolicyStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterSecurityPolicy",
-                    securityPolicyStructClass);
+                    securityPolicyStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ThreadNetworkDiagnosticsClusterSecurityPolicy");
                     return nullptr;
                 }
-                jmethodID securityPolicyStructCtor =
-                    env->GetMethodID(securityPolicyStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
-                if (securityPolicyStructCtor == nullptr)
+                jmethodID securityPolicyStructCtor_1 =
+                    env->GetMethodID(securityPolicyStructClass_1, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+                if (securityPolicyStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ThreadNetworkDiagnosticsClusterSecurityPolicy constructor");
                     return nullptr;
                 }
 
-                value = env->NewObject(securityPolicyStructClass, securityPolicyStructCtor, value_rotationTime, value_flags);
+                value = env->NewObject(securityPolicyStructClass_1, securityPolicyStructCtor_1, value_rotationTime, value_flags);
             }
             return value;
         }
@@ -6729,29 +6733,29 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                     value_channelMaskPresentClassName.c_str(), value_channelMaskPresentCtorSignature.c_str(),
                     cppValue.Value().channelMaskPresent, value_channelMaskPresent);
 
-                jclass operationalDatasetComponentsStructClass;
+                jclass operationalDatasetComponentsStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterOperationalDatasetComponents",
-                    operationalDatasetComponentsStructClass);
+                    operationalDatasetComponentsStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl,
                                  "Could not find class ChipStructs$ThreadNetworkDiagnosticsClusterOperationalDatasetComponents");
                     return nullptr;
                 }
-                jmethodID operationalDatasetComponentsStructCtor =
-                    env->GetMethodID(operationalDatasetComponentsStructClass, "<init>",
+                jmethodID operationalDatasetComponentsStructCtor_1 =
+                    env->GetMethodID(operationalDatasetComponentsStructClass_1, "<init>",
                                      "(Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/"
                                      "Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/"
                                      "lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;)V");
-                if (operationalDatasetComponentsStructCtor == nullptr)
+                if (operationalDatasetComponentsStructCtor_1 == nullptr)
                 {
                     ChipLogError(
                         Zcl, "Could not find ChipStructs$ThreadNetworkDiagnosticsClusterOperationalDatasetComponents constructor");
                     return nullptr;
                 }
 
-                value = env->NewObject(operationalDatasetComponentsStructClass, operationalDatasetComponentsStructCtor,
+                value = env->NewObject(operationalDatasetComponentsStructClass_1, operationalDatasetComponentsStructCtor_1,
                                        value_activeTimestampPresent, value_pendingTimestampPresent, value_masterKeyPresent,
                                        value_networkNamePresent, value_extendedPanIdPresent, value_meshLocalPrefixPresent,
                                        value_delayPresent, value_panIdPresent, value_channelPresent, value_pskcPresent,
@@ -8163,22 +8167,22 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass NOCStructStructClass;
+                jclass NOCStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$OperationalCredentialsClusterNOCStruct", NOCStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$OperationalCredentialsClusterNOCStruct", NOCStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$OperationalCredentialsClusterNOCStruct");
                     return nullptr;
                 }
-                jmethodID NOCStructStructCtor = env->GetMethodID(NOCStructStructClass, "<init>", "([B[BLjava/lang/Integer;)V");
-                if (NOCStructStructCtor == nullptr)
+                jmethodID NOCStructStructCtor_1 = env->GetMethodID(NOCStructStructClass_1, "<init>", "([B[BLjava/lang/Integer;)V");
+                if (NOCStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$OperationalCredentialsClusterNOCStruct constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(NOCStructStructClass, NOCStructStructCtor, newElement_0_noc, newElement_0_icac,
+                newElement_0 = env->NewObject(NOCStructStructClass_1, NOCStructStructCtor_1, newElement_0_noc, newElement_0_icac,
                                               newElement_0_fabricIndex);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -8233,27 +8237,27 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass fabricDescriptorStructClass;
+                jclass fabricDescriptorStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$OperationalCredentialsClusterFabricDescriptor",
-                    fabricDescriptorStructClass);
+                    fabricDescriptorStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$OperationalCredentialsClusterFabricDescriptor");
                     return nullptr;
                 }
-                jmethodID fabricDescriptorStructCtor = env->GetMethodID(
-                    fabricDescriptorStructClass, "<init>",
+                jmethodID fabricDescriptorStructCtor_1 = env->GetMethodID(
+                    fabricDescriptorStructClass_1, "<init>",
                     "([BLjava/lang/Integer;Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/String;Ljava/lang/Integer;)V");
-                if (fabricDescriptorStructCtor == nullptr)
+                if (fabricDescriptorStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$OperationalCredentialsClusterFabricDescriptor constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(fabricDescriptorStructClass, fabricDescriptorStructCtor, newElement_0_rootPublicKey,
-                                              newElement_0_vendorId, newElement_0_fabricId, newElement_0_nodeId, newElement_0_label,
-                                              newElement_0_fabricIndex);
+                newElement_0 = env->NewObject(fabricDescriptorStructClass_1, fabricDescriptorStructCtor_1,
+                                              newElement_0_rootPublicKey, newElement_0_vendorId, newElement_0_fabricId,
+                                              newElement_0_nodeId, newElement_0_label, newElement_0_fabricIndex);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -8474,24 +8478,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass groupKeyMapStructStructClass;
+                jclass groupKeyMapStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupKeyMapStruct",
-                    groupKeyMapStructStructClass);
+                    groupKeyMapStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$GroupKeyManagementClusterGroupKeyMapStruct");
                     return nullptr;
                 }
-                jmethodID groupKeyMapStructStructCtor = env->GetMethodID(
-                    groupKeyMapStructStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
-                if (groupKeyMapStructStructCtor == nullptr)
+                jmethodID groupKeyMapStructStructCtor_1 = env->GetMethodID(
+                    groupKeyMapStructStructClass_1, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
+                if (groupKeyMapStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$GroupKeyManagementClusterGroupKeyMapStruct constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(groupKeyMapStructStructClass, groupKeyMapStructStructCtor, newElement_0_groupId,
+                newElement_0 = env->NewObject(groupKeyMapStructStructClass_1, groupKeyMapStructStructCtor_1, newElement_0_groupId,
                                               newElement_0_groupKeySetID, newElement_0_fabricIndex);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -8552,25 +8556,25 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass groupInfoMapStructStructClass;
+                jclass groupInfoMapStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupInfoMapStruct",
-                    groupInfoMapStructStructClass);
+                    groupInfoMapStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$GroupKeyManagementClusterGroupInfoMapStruct");
                     return nullptr;
                 }
-                jmethodID groupInfoMapStructStructCtor =
-                    env->GetMethodID(groupInfoMapStructStructClass, "<init>",
+                jmethodID groupInfoMapStructStructCtor_1 =
+                    env->GetMethodID(groupInfoMapStructStructClass_1, "<init>",
                                      "(Ljava/lang/Integer;Ljava/util/ArrayList;Ljava/util/Optional;Ljava/lang/Integer;)V");
-                if (groupInfoMapStructStructCtor == nullptr)
+                if (groupInfoMapStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$GroupKeyManagementClusterGroupInfoMapStruct constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(groupInfoMapStructStructClass, groupInfoMapStructStructCtor, newElement_0_groupId,
+                newElement_0 = env->NewObject(groupInfoMapStructStructClass_1, groupInfoMapStructStructCtor_1, newElement_0_groupId,
                                               newElement_0_endpoints, newElement_0_groupName, newElement_0_fabricIndex);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -8739,24 +8743,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 jobject newElement_0_value;
                 newElement_0_value = env->NewStringUTF(std::string(entry_0.value.data(), entry_0.value.size()).c_str());
 
-                jclass labelStructStructClass;
+                jclass labelStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$FixedLabelClusterLabelStruct", labelStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$FixedLabelClusterLabelStruct", labelStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$FixedLabelClusterLabelStruct");
                     return nullptr;
                 }
-                jmethodID labelStructStructCtor =
-                    env->GetMethodID(labelStructStructClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
-                if (labelStructStructCtor == nullptr)
+                jmethodID labelStructStructCtor_1 =
+                    env->GetMethodID(labelStructStructClass_1, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
+                if (labelStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$FixedLabelClusterLabelStruct constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(labelStructStructClass, labelStructStructCtor, newElement_0_label, newElement_0_value);
+                    env->NewObject(labelStructStructClass_1, labelStructStructCtor_1, newElement_0_label, newElement_0_value);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -8894,24 +8898,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 jobject newElement_0_value;
                 newElement_0_value = env->NewStringUTF(std::string(entry_0.value.data(), entry_0.value.size()).c_str());
 
-                jclass labelStructStructClass;
+                jclass labelStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$UserLabelClusterLabelStruct", labelStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$UserLabelClusterLabelStruct", labelStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$UserLabelClusterLabelStruct");
                     return nullptr;
                 }
-                jmethodID labelStructStructCtor =
-                    env->GetMethodID(labelStructStructClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
-                if (labelStructStructCtor == nullptr)
+                jmethodID labelStructStructCtor_1 =
+                    env->GetMethodID(labelStructStructClass_1, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
+                if (labelStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$UserLabelClusterLabelStruct constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(labelStructStructClass, labelStructStructCtor, newElement_0_label, newElement_0_value);
+                    env->NewObject(labelStructStructClass_1, labelStructStructCtor_1, newElement_0_label, newElement_0_value);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -9209,44 +9213,44 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                                    newElement_2_valueCtorSignature.c_str(),
                                                                                    entry_2.value, newElement_2_value);
 
-                    jclass semanticTagStructClass;
+                    jclass semanticTagStructClass_3;
                     err = chip::JniReferences::GetInstance().GetClassRef(
-                        env, "chip/devicecontroller/ChipStructs$ModeSelectClusterSemanticTag", semanticTagStructClass);
+                        env, "chip/devicecontroller/ChipStructs$ModeSelectClusterSemanticTag", semanticTagStructClass_3);
                     if (err != CHIP_NO_ERROR)
                     {
                         ChipLogError(Zcl, "Could not find class ChipStructs$ModeSelectClusterSemanticTag");
                         return nullptr;
                     }
-                    jmethodID semanticTagStructCtor =
-                        env->GetMethodID(semanticTagStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
-                    if (semanticTagStructCtor == nullptr)
+                    jmethodID semanticTagStructCtor_3 =
+                        env->GetMethodID(semanticTagStructClass_3, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+                    if (semanticTagStructCtor_3 == nullptr)
                     {
                         ChipLogError(Zcl, "Could not find ChipStructs$ModeSelectClusterSemanticTag constructor");
                         return nullptr;
                     }
 
                     newElement_2 =
-                        env->NewObject(semanticTagStructClass, semanticTagStructCtor, newElement_2_mfgCode, newElement_2_value);
+                        env->NewObject(semanticTagStructClass_3, semanticTagStructCtor_3, newElement_2_mfgCode, newElement_2_value);
                     chip::JniReferences::GetInstance().AddToList(newElement_0_semanticTags, newElement_2);
                 }
 
-                jclass modeOptionStructStructClass;
+                jclass modeOptionStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$ModeSelectClusterModeOptionStruct", modeOptionStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$ModeSelectClusterModeOptionStruct", modeOptionStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ModeSelectClusterModeOptionStruct");
                     return nullptr;
                 }
-                jmethodID modeOptionStructStructCtor = env->GetMethodID(
-                    modeOptionStructStructClass, "<init>", "(Ljava/lang/String;Ljava/lang/Integer;Ljava/util/ArrayList;)V");
-                if (modeOptionStructStructCtor == nullptr)
+                jmethodID modeOptionStructStructCtor_1 = env->GetMethodID(
+                    modeOptionStructStructClass_1, "<init>", "(Ljava/lang/String;Ljava/lang/Integer;Ljava/util/ArrayList;)V");
+                if (modeOptionStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ModeSelectClusterModeOptionStruct constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(modeOptionStructStructClass, modeOptionStructStructCtor, newElement_0_label,
+                newElement_0 = env->NewObject(modeOptionStructStructClass_1, modeOptionStructStructCtor_1, newElement_0_label,
                                               newElement_0_mode, newElement_0_semanticTags);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -14241,24 +14245,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                       newElement_0_affiliateCallSign);
                 }
 
-                jclass channelInfoStructClass;
+                jclass channelInfoStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$ChannelClusterChannelInfo", channelInfoStructClass);
+                    env, "chip/devicecontroller/ChipStructs$ChannelClusterChannelInfo", channelInfoStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ChannelClusterChannelInfo");
                     return nullptr;
                 }
-                jmethodID channelInfoStructCtor = env->GetMethodID(
-                    channelInfoStructClass, "<init>",
+                jmethodID channelInfoStructCtor_1 = env->GetMethodID(
+                    channelInfoStructClass_1, "<init>",
                     "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V");
-                if (channelInfoStructCtor == nullptr)
+                if (channelInfoStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ChannelClusterChannelInfo constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(channelInfoStructClass, channelInfoStructCtor, newElement_0_majorNumber,
+                newElement_0 = env->NewObject(channelInfoStructClass_1, channelInfoStructCtor_1, newElement_0_majorNumber,
                                               newElement_0_minorNumber, newElement_0_name, newElement_0_callSign,
                                               newElement_0_affiliateCallSign);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
@@ -14316,24 +14320,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                     value_lineupInfoTypeClassName.c_str(), value_lineupInfoTypeCtorSignature.c_str(),
                     static_cast<uint8_t>(cppValue.Value().lineupInfoType), value_lineupInfoType);
 
-                jclass lineupInfoStructClass;
+                jclass lineupInfoStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$ChannelClusterLineupInfo", lineupInfoStructClass);
+                    env, "chip/devicecontroller/ChipStructs$ChannelClusterLineupInfo", lineupInfoStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ChannelClusterLineupInfo");
                     return nullptr;
                 }
-                jmethodID lineupInfoStructCtor =
-                    env->GetMethodID(lineupInfoStructClass, "<init>",
+                jmethodID lineupInfoStructCtor_1 =
+                    env->GetMethodID(lineupInfoStructClass_1, "<init>",
                                      "(Ljava/lang/String;Ljava/util/Optional;Ljava/util/Optional;Ljava/lang/Integer;)V");
-                if (lineupInfoStructCtor == nullptr)
+                if (lineupInfoStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ChannelClusterLineupInfo constructor");
                     return nullptr;
                 }
 
-                value = env->NewObject(lineupInfoStructClass, lineupInfoStructCtor, value_operatorName, value_lineupName,
+                value = env->NewObject(lineupInfoStructClass_1, lineupInfoStructCtor_1, value_operatorName, value_lineupName,
                                        value_postalCode, value_lineupInfoType);
             }
             return value;
@@ -14405,24 +14409,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                       value_affiliateCallSign);
                 }
 
-                jclass channelInfoStructClass;
+                jclass channelInfoStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$ChannelClusterChannelInfo", channelInfoStructClass);
+                    env, "chip/devicecontroller/ChipStructs$ChannelClusterChannelInfo", channelInfoStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ChannelClusterChannelInfo");
                     return nullptr;
                 }
-                jmethodID channelInfoStructCtor = env->GetMethodID(
-                    channelInfoStructClass, "<init>",
+                jmethodID channelInfoStructCtor_1 = env->GetMethodID(
+                    channelInfoStructClass_1, "<init>",
                     "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V");
-                if (channelInfoStructCtor == nullptr)
+                if (channelInfoStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ChannelClusterChannelInfo constructor");
                     return nullptr;
                 }
 
-                value = env->NewObject(channelInfoStructClass, channelInfoStructCtor, value_majorNumber, value_minorNumber,
+                value = env->NewObject(channelInfoStructClass_1, channelInfoStructCtor_1, value_majorNumber, value_minorNumber,
                                        value_name, value_callSign, value_affiliateCallSign);
             }
             return value;
@@ -14564,24 +14568,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 jobject newElement_0_name;
                 newElement_0_name = env->NewStringUTF(std::string(entry_0.name.data(), entry_0.name.size()).c_str());
 
-                jclass targetInfoStructClass;
+                jclass targetInfoStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$TargetNavigatorClusterTargetInfo", targetInfoStructClass);
+                    env, "chip/devicecontroller/ChipStructs$TargetNavigatorClusterTargetInfo", targetInfoStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$TargetNavigatorClusterTargetInfo");
                     return nullptr;
                 }
-                jmethodID targetInfoStructCtor =
-                    env->GetMethodID(targetInfoStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
-                if (targetInfoStructCtor == nullptr)
+                jmethodID targetInfoStructCtor_1 =
+                    env->GetMethodID(targetInfoStructClass_1, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
+                if (targetInfoStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$TargetNavigatorClusterTargetInfo constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(targetInfoStructClass, targetInfoStructCtor, newElement_0_identifier, newElement_0_name);
+                    env->NewObject(targetInfoStructClass_1, targetInfoStructCtor_1, newElement_0_identifier, newElement_0_name);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -14807,23 +14811,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                         value_position);
                 }
 
-                jclass playbackPositionStructClass;
+                jclass playbackPositionStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$MediaPlaybackClusterPlaybackPosition", playbackPositionStructClass);
+                    env, "chip/devicecontroller/ChipStructs$MediaPlaybackClusterPlaybackPosition", playbackPositionStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$MediaPlaybackClusterPlaybackPosition");
                     return nullptr;
                 }
-                jmethodID playbackPositionStructCtor =
-                    env->GetMethodID(playbackPositionStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Long;)V");
-                if (playbackPositionStructCtor == nullptr)
+                jmethodID playbackPositionStructCtor_1 =
+                    env->GetMethodID(playbackPositionStructClass_1, "<init>", "(Ljava/lang/Long;Ljava/lang/Long;)V");
+                if (playbackPositionStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$MediaPlaybackClusterPlaybackPosition constructor");
                     return nullptr;
                 }
 
-                value = env->NewObject(playbackPositionStructClass, playbackPositionStructCtor, value_updatedAt, value_position);
+                value =
+                    env->NewObject(playbackPositionStructClass_1, playbackPositionStructCtor_1, value_updatedAt, value_position);
             }
             return value;
         }
@@ -15032,25 +15037,25 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 newElement_0_description =
                     env->NewStringUTF(std::string(entry_0.description.data(), entry_0.description.size()).c_str());
 
-                jclass inputInfoStructClass;
+                jclass inputInfoStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$MediaInputClusterInputInfo", inputInfoStructClass);
+                    env, "chip/devicecontroller/ChipStructs$MediaInputClusterInputInfo", inputInfoStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$MediaInputClusterInputInfo");
                     return nullptr;
                 }
-                jmethodID inputInfoStructCtor =
-                    env->GetMethodID(inputInfoStructClass, "<init>",
+                jmethodID inputInfoStructCtor_1 =
+                    env->GetMethodID(inputInfoStructClass_1, "<init>",
                                      "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;)V");
-                if (inputInfoStructCtor == nullptr)
+                if (inputInfoStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$MediaInputClusterInputInfo constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(inputInfoStructClass, inputInfoStructCtor, newElement_0_index, newElement_0_inputType,
-                                              newElement_0_name, newElement_0_description);
+                newElement_0 = env->NewObject(inputInfoStructClass_1, inputInfoStructCtor_1, newElement_0_index,
+                                              newElement_0_inputType, newElement_0_name, newElement_0_description);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -15585,23 +15590,23 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 jobject newElement_0_name;
                 newElement_0_name = env->NewStringUTF(std::string(entry_0.name.data(), entry_0.name.size()).c_str());
 
-                jclass outputInfoStructClass;
+                jclass outputInfoStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$AudioOutputClusterOutputInfo", outputInfoStructClass);
+                    env, "chip/devicecontroller/ChipStructs$AudioOutputClusterOutputInfo", outputInfoStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$AudioOutputClusterOutputInfo");
                     return nullptr;
                 }
-                jmethodID outputInfoStructCtor = env->GetMethodID(outputInfoStructClass, "<init>",
-                                                                  "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;)V");
-                if (outputInfoStructCtor == nullptr)
+                jmethodID outputInfoStructCtor_1 = env->GetMethodID(outputInfoStructClass_1, "<init>",
+                                                                    "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;)V");
+                if (outputInfoStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$AudioOutputClusterOutputInfo constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(outputInfoStructClass, outputInfoStructCtor, newElement_0_index,
+                newElement_0 = env->NewObject(outputInfoStructClass_1, outputInfoStructCtor_1, newElement_0_index,
                                               newElement_0_outputType, newElement_0_name);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
@@ -15785,24 +15790,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                                 cppValue.Value().application.applicationId.size())
                                                                         .c_str());
 
-                jclass applicationStructClass;
+                jclass applicationStructClass_2;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$ApplicationLauncherClusterApplication", applicationStructClass);
+                    env, "chip/devicecontroller/ChipStructs$ApplicationLauncherClusterApplication", applicationStructClass_2);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ApplicationLauncherClusterApplication");
                     return nullptr;
                 }
-                jmethodID applicationStructCtor =
-                    env->GetMethodID(applicationStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
-                if (applicationStructCtor == nullptr)
+                jmethodID applicationStructCtor_2 =
+                    env->GetMethodID(applicationStructClass_2, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
+                if (applicationStructCtor_2 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ApplicationLauncherClusterApplication constructor");
                     return nullptr;
                 }
 
-                value_application = env->NewObject(applicationStructClass, applicationStructCtor, value_application_catalogVendorId,
-                                                   value_application_applicationId);
+                value_application = env->NewObject(applicationStructClass_2, applicationStructCtor_2,
+                                                   value_application_catalogVendorId, value_application_applicationId);
                 jobject value_endpoint;
                 if (!cppValue.Value().endpoint.HasValue())
                 {
@@ -15819,24 +15824,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                     chip::JniReferences::GetInstance().CreateOptional(value_endpointInsideOptional, value_endpoint);
                 }
 
-                jclass applicationEPStructClass;
+                jclass applicationEPStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$ApplicationLauncherClusterApplicationEP", applicationEPStructClass);
+                    env, "chip/devicecontroller/ChipStructs$ApplicationLauncherClusterApplicationEP", applicationEPStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ApplicationLauncherClusterApplicationEP");
                     return nullptr;
                 }
-                jmethodID applicationEPStructCtor = env->GetMethodID(
-                    applicationEPStructClass, "<init>",
+                jmethodID applicationEPStructCtor_1 = env->GetMethodID(
+                    applicationEPStructClass_1, "<init>",
                     "(Lchip/devicecontroller/ChipStructs$ApplicationLauncherClusterApplication;Ljava/util/Optional;)V");
-                if (applicationEPStructCtor == nullptr)
+                if (applicationEPStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ApplicationLauncherClusterApplicationEP constructor");
                     return nullptr;
                 }
 
-                value = env->NewObject(applicationEPStructClass, applicationEPStructCtor, value_application, value_endpoint);
+                value = env->NewObject(applicationEPStructClass_1, applicationEPStructCtor_1, value_application, value_endpoint);
             }
             return value;
         }
@@ -16025,24 +16030,24 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
             value_applicationId =
                 env->NewStringUTF(std::string(cppValue.applicationId.data(), cppValue.applicationId.size()).c_str());
 
-            jclass applicationBasicApplicationStructClass;
+            jclass applicationBasicApplicationStructClass_0;
             err = chip::JniReferences::GetInstance().GetClassRef(
                 env, "chip/devicecontroller/ChipStructs$ApplicationBasicClusterApplicationBasicApplication",
-                applicationBasicApplicationStructClass);
+                applicationBasicApplicationStructClass_0);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$ApplicationBasicClusterApplicationBasicApplication");
                 return nullptr;
             }
-            jmethodID applicationBasicApplicationStructCtor =
-                env->GetMethodID(applicationBasicApplicationStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
-            if (applicationBasicApplicationStructCtor == nullptr)
+            jmethodID applicationBasicApplicationStructCtor_0 =
+                env->GetMethodID(applicationBasicApplicationStructClass_0, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
+            if (applicationBasicApplicationStructCtor_0 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$ApplicationBasicClusterApplicationBasicApplication constructor");
                 return nullptr;
             }
 
-            value = env->NewObject(applicationBasicApplicationStructClass, applicationBasicApplicationStructCtor,
+            value = env->NewObject(applicationBasicApplicationStructClass_0, applicationBasicApplicationStructCtor_0,
                                    value_catalogVendorId, value_applicationId);
             return value;
         }
@@ -17064,24 +17069,25 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                         reinterpret_cast<const jbyte *>(entry_0.member2.data()));
                 newElement_0_member2 = newElement_0_member2ByteArray;
 
-                jclass testListStructOctetStructClass;
+                jclass testListStructOctetStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterTestListStructOctet", testListStructOctetStructClass);
+                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterTestListStructOctet",
+                    testListStructOctetStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterTestListStructOctet");
                     return nullptr;
                 }
-                jmethodID testListStructOctetStructCtor =
-                    env->GetMethodID(testListStructOctetStructClass, "<init>", "(Ljava/lang/Long;[B)V");
-                if (testListStructOctetStructCtor == nullptr)
+                jmethodID testListStructOctetStructCtor_1 =
+                    env->GetMethodID(testListStructOctetStructClass_1, "<init>", "(Ljava/lang/Long;[B)V");
+                if (testListStructOctetStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterTestListStructOctet constructor");
                     return nullptr;
                 }
 
-                newElement_0 = env->NewObject(testListStructOctetStructClass, testListStructOctetStructCtor, newElement_0_member1,
-                                              newElement_0_member2);
+                newElement_0 = env->NewObject(testListStructOctetStructClass_1, testListStructOctetStructCtor_1,
+                                              newElement_0_member1, newElement_0_member2);
                 chip::JniReferences::GetInstance().AddToList(value, newElement_0);
             }
             return value;
@@ -17339,26 +17345,26 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                         newElement_0_nullableStruct_hClassName.c_str(), newElement_0_nullableStruct_hCtorSignature.c_str(),
                         entry_0.nullableStruct.Value().h, newElement_0_nullableStruct_h);
 
-                    jclass simpleStructStructClass;
+                    jclass simpleStructStructClass_3;
                     err = chip::JniReferences::GetInstance().GetClassRef(
-                        env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                        env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_3);
                     if (err != CHIP_NO_ERROR)
                     {
                         ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                         return nullptr;
                     }
-                    jmethodID simpleStructStructCtor =
-                        env->GetMethodID(simpleStructStructClass, "<init>",
+                    jmethodID simpleStructStructCtor_3 =
+                        env->GetMethodID(simpleStructStructClass_3, "<init>",
                                          "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
                                          "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-                    if (simpleStructStructCtor == nullptr)
+                    if (simpleStructStructCtor_3 == nullptr)
                     {
                         ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                         return nullptr;
                     }
 
                     newElement_0_nullableStruct =
-                        env->NewObject(simpleStructStructClass, simpleStructStructCtor, newElement_0_nullableStruct_a,
+                        env->NewObject(simpleStructStructClass_3, simpleStructStructCtor_3, newElement_0_nullableStruct_a,
                                        newElement_0_nullableStruct_b, newElement_0_nullableStruct_c, newElement_0_nullableStruct_d,
                                        newElement_0_nullableStruct_e, newElement_0_nullableStruct_f, newElement_0_nullableStruct_g,
                                        newElement_0_nullableStruct_h);
@@ -17424,30 +17430,30 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                         newElement_0_optionalStructInsideOptional_hCtorSignature.c_str(), entry_0.optionalStruct.Value().h,
                         newElement_0_optionalStructInsideOptional_h);
 
-                    jclass simpleStructStructClass;
+                    jclass simpleStructStructClass_3;
                     err = chip::JniReferences::GetInstance().GetClassRef(
-                        env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                        env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_3);
                     if (err != CHIP_NO_ERROR)
                     {
                         ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                         return nullptr;
                     }
-                    jmethodID simpleStructStructCtor =
-                        env->GetMethodID(simpleStructStructClass, "<init>",
+                    jmethodID simpleStructStructCtor_3 =
+                        env->GetMethodID(simpleStructStructClass_3, "<init>",
                                          "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
                                          "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-                    if (simpleStructStructCtor == nullptr)
+                    if (simpleStructStructCtor_3 == nullptr)
                     {
                         ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                         return nullptr;
                     }
 
                     newElement_0_optionalStructInsideOptional =
-                        env->NewObject(simpleStructStructClass, simpleStructStructCtor, newElement_0_optionalStructInsideOptional_a,
-                                       newElement_0_optionalStructInsideOptional_b, newElement_0_optionalStructInsideOptional_c,
-                                       newElement_0_optionalStructInsideOptional_d, newElement_0_optionalStructInsideOptional_e,
-                                       newElement_0_optionalStructInsideOptional_f, newElement_0_optionalStructInsideOptional_g,
-                                       newElement_0_optionalStructInsideOptional_h);
+                        env->NewObject(simpleStructStructClass_3, simpleStructStructCtor_3,
+                                       newElement_0_optionalStructInsideOptional_a, newElement_0_optionalStructInsideOptional_b,
+                                       newElement_0_optionalStructInsideOptional_c, newElement_0_optionalStructInsideOptional_d,
+                                       newElement_0_optionalStructInsideOptional_e, newElement_0_optionalStructInsideOptional_f,
+                                       newElement_0_optionalStructInsideOptional_g, newElement_0_optionalStructInsideOptional_h);
                     chip::JniReferences::GetInstance().CreateOptional(newElement_0_optionalStructInsideOptional,
                                                                       newElement_0_optionalStruct);
                 }
@@ -17524,33 +17530,34 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                             newElement_0_nullableOptionalStructInsideOptional_hCtorSignature.c_str(),
                             entry_0.nullableOptionalStruct.Value().Value().h, newElement_0_nullableOptionalStructInsideOptional_h);
 
-                        jclass simpleStructStructClass;
+                        jclass simpleStructStructClass_4;
                         err = chip::JniReferences::GetInstance().GetClassRef(
-                            env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                            env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_4);
                         if (err != CHIP_NO_ERROR)
                         {
                             ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                             return nullptr;
                         }
-                        jmethodID simpleStructStructCtor =
-                            env->GetMethodID(simpleStructStructClass, "<init>",
+                        jmethodID simpleStructStructCtor_4 =
+                            env->GetMethodID(simpleStructStructClass_4, "<init>",
                                              "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/"
                                              "lang/Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-                        if (simpleStructStructCtor == nullptr)
+                        if (simpleStructStructCtor_4 == nullptr)
                         {
                             ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                             return nullptr;
                         }
 
-                        newElement_0_nullableOptionalStructInsideOptional = env->NewObject(
-                            simpleStructStructClass, simpleStructStructCtor, newElement_0_nullableOptionalStructInsideOptional_a,
-                            newElement_0_nullableOptionalStructInsideOptional_b,
-                            newElement_0_nullableOptionalStructInsideOptional_c,
-                            newElement_0_nullableOptionalStructInsideOptional_d,
-                            newElement_0_nullableOptionalStructInsideOptional_e,
-                            newElement_0_nullableOptionalStructInsideOptional_f,
-                            newElement_0_nullableOptionalStructInsideOptional_g,
-                            newElement_0_nullableOptionalStructInsideOptional_h);
+                        newElement_0_nullableOptionalStructInsideOptional =
+                            env->NewObject(simpleStructStructClass_4, simpleStructStructCtor_4,
+                                           newElement_0_nullableOptionalStructInsideOptional_a,
+                                           newElement_0_nullableOptionalStructInsideOptional_b,
+                                           newElement_0_nullableOptionalStructInsideOptional_c,
+                                           newElement_0_nullableOptionalStructInsideOptional_d,
+                                           newElement_0_nullableOptionalStructInsideOptional_e,
+                                           newElement_0_nullableOptionalStructInsideOptional_f,
+                                           newElement_0_nullableOptionalStructInsideOptional_g,
+                                           newElement_0_nullableOptionalStructInsideOptional_h);
                     }
                     chip::JniReferences::GetInstance().CreateOptional(newElement_0_nullableOptionalStructInsideOptional,
                                                                       newElement_0_nullableOptionalStruct);
@@ -17637,28 +17644,28 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                       newElement_0_nullableOptionalList);
                 }
 
-                jclass nullablesAndOptionalsStructStructClass;
+                jclass nullablesAndOptionalsStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
                     env, "chip/devicecontroller/ChipStructs$TestClusterClusterNullablesAndOptionalsStruct",
-                    nullablesAndOptionalsStructStructClass);
+                    nullablesAndOptionalsStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterNullablesAndOptionalsStruct");
                     return nullptr;
                 }
-                jmethodID nullablesAndOptionalsStructStructCtor = env->GetMethodID(
-                    nullablesAndOptionalsStructStructClass, "<init>",
+                jmethodID nullablesAndOptionalsStructStructCtor_1 = env->GetMethodID(
+                    nullablesAndOptionalsStructStructClass_1, "<init>",
                     "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;Ljava/lang/String;Ljava/util/Optional;Ljava/util/"
                     "Optional;Lchip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct;Ljava/util/Optional;Ljava/util/"
                     "Optional;Ljava/util/ArrayList;Ljava/util/Optional;Ljava/util/Optional;)V");
-                if (nullablesAndOptionalsStructStructCtor == nullptr)
+                if (nullablesAndOptionalsStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterNullablesAndOptionalsStruct constructor");
                     return nullptr;
                 }
 
                 newElement_0 =
-                    env->NewObject(nullablesAndOptionalsStructStructClass, nullablesAndOptionalsStructStructCtor,
+                    env->NewObject(nullablesAndOptionalsStructStructClass_1, nullablesAndOptionalsStructStructCtor_1,
                                    newElement_0_nullableInt, newElement_0_optionalInt, newElement_0_nullableOptionalInt,
                                    newElement_0_nullableString, newElement_0_optionalString, newElement_0_nullableOptionalString,
                                    newElement_0_nullableStruct, newElement_0_optionalStruct, newElement_0_nullableOptionalStruct,
@@ -17729,25 +17736,25 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
             chip::JniReferences::GetInstance().CreateBoxedObject<double>(value_hClassName.c_str(), value_hCtorSignature.c_str(),
                                                                          cppValue.h, value_h);
 
-            jclass simpleStructStructClass;
+            jclass simpleStructStructClass_0;
             err = chip::JniReferences::GetInstance().GetClassRef(
-                env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_0);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                 return nullptr;
             }
-            jmethodID simpleStructStructCtor =
-                env->GetMethodID(simpleStructStructClass, "<init>",
+            jmethodID simpleStructStructCtor_0 =
+                env->GetMethodID(simpleStructStructClass_0, "<init>",
                                  "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
                                  "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-            if (simpleStructStructCtor == nullptr)
+            if (simpleStructStructCtor_0 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                 return nullptr;
             }
 
-            value = env->NewObject(simpleStructStructClass, simpleStructStructCtor, value_a, value_b, value_c, value_d, value_e,
+            value = env->NewObject(simpleStructStructClass_0, simpleStructStructCtor_0, value_a, value_b, value_c, value_d, value_e,
                                    value_f, value_g, value_h);
             return value;
         }
@@ -17971,26 +17978,26 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                     newElement_0_fabricSensitiveStruct_hCtorSignature.c_str(), entry_0.fabricSensitiveStruct.h,
                     newElement_0_fabricSensitiveStruct_h);
 
-                jclass simpleStructStructClass;
+                jclass simpleStructStructClass_2;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_2);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                     return nullptr;
                 }
-                jmethodID simpleStructStructCtor =
-                    env->GetMethodID(simpleStructStructClass, "<init>",
+                jmethodID simpleStructStructCtor_2 =
+                    env->GetMethodID(simpleStructStructClass_2, "<init>",
                                      "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
                                      "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-                if (simpleStructStructCtor == nullptr)
+                if (simpleStructStructCtor_2 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                     return nullptr;
                 }
 
                 newElement_0_fabricSensitiveStruct =
-                    env->NewObject(simpleStructStructClass, simpleStructStructCtor, newElement_0_fabricSensitiveStruct_a,
+                    env->NewObject(simpleStructStructClass_2, simpleStructStructCtor_2, newElement_0_fabricSensitiveStruct_a,
                                    newElement_0_fabricSensitiveStruct_b, newElement_0_fabricSensitiveStruct_c,
                                    newElement_0_fabricSensitiveStruct_d, newElement_0_fabricSensitiveStruct_e,
                                    newElement_0_fabricSensitiveStruct_f, newElement_0_fabricSensitiveStruct_g,
@@ -18016,26 +18023,26 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                                                                               newElement_0_fabricIndexCtorSignature.c_str(),
                                                                               entry_0.fabricIndex, newElement_0_fabricIndex);
 
-                jclass testFabricScopedStructClass;
+                jclass testFabricScopedStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterTestFabricScoped", testFabricScopedStructClass);
+                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterTestFabricScoped", testFabricScopedStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterTestFabricScoped");
                     return nullptr;
                 }
-                jmethodID testFabricScopedStructCtor = env->GetMethodID(
-                    testFabricScopedStructClass, "<init>",
+                jmethodID testFabricScopedStructCtor_1 = env->GetMethodID(
+                    testFabricScopedStructClass_1, "<init>",
                     "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/lang/Integer;Ljava/util/Optional;Ljava/lang/String;Lchip/"
                     "devicecontroller/ChipStructs$TestClusterClusterSimpleStruct;Ljava/util/ArrayList;Ljava/lang/Integer;)V");
-                if (testFabricScopedStructCtor == nullptr)
+                if (testFabricScopedStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterTestFabricScoped constructor");
                     return nullptr;
                 }
 
                 newElement_0 = env->NewObject(
-                    testFabricScopedStructClass, testFabricScopedStructCtor, newElement_0_fabricSensitiveInt8u,
+                    testFabricScopedStructClass_1, testFabricScopedStructCtor_1, newElement_0_fabricSensitiveInt8u,
                     newElement_0_optionalFabricSensitiveInt8u, newElement_0_nullableFabricSensitiveInt8u,
                     newElement_0_nullableOptionalFabricSensitiveInt8u, newElement_0_fabricSensitiveCharString,
                     newElement_0_fabricSensitiveStruct, newElement_0_fabricSensitiveInt8uList, newElement_0_fabricIndex);
@@ -18769,26 +18776,26 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
                 chip::JniReferences::GetInstance().CreateBoxedObject<double>(value_hClassName.c_str(), value_hCtorSignature.c_str(),
                                                                              cppValue.Value().h, value_h);
 
-                jclass simpleStructStructClass;
+                jclass simpleStructStructClass_1;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_1);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                     return nullptr;
                 }
-                jmethodID simpleStructStructCtor =
-                    env->GetMethodID(simpleStructStructClass, "<init>",
+                jmethodID simpleStructStructCtor_1 =
+                    env->GetMethodID(simpleStructStructClass_1, "<init>",
                                      "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
                                      "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-                if (simpleStructStructCtor == nullptr)
+                if (simpleStructStructCtor_1 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                     return nullptr;
                 }
 
-                value = env->NewObject(simpleStructStructClass, simpleStructStructCtor, value_a, value_b, value_c, value_d, value_e,
-                                       value_f, value_g, value_h);
+                value = env->NewObject(simpleStructStructClass_1, simpleStructStructCtor_1, value_a, value_b, value_c, value_d,
+                                       value_e, value_f, value_g, value_h);
             }
             return value;
         }
diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp
new file mode 100644
index 00000000000000..ba9dfaefd0fb23
--- /dev/null
+++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp
@@ -0,0 +1,3427 @@
+/*
+ *
+ *    Copyright (c) 2022 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include <controller/java/CHIPAttributeTLVValueDecoder.h>
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app-common/zap-generated/ids/Events.h>
+#include <app/data-model/DecodableList.h>
+#include <app/data-model/Decode.h>
+#include <jni.h>
+#include <lib/support/JniReferences.h>
+#include <lib/support/JniTypeWrappers.h>
+#include <lib/support/TypeTraits.h>
+
+namespace chip {
+
+jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & aReader, CHIP_ERROR * aError)
+{
+    JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    switch (aPath.mClusterId)
+    {
+    case app::Clusters::Identify::Id: {
+        using namespace app::Clusters::Identify;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::Groups::Id: {
+        using namespace app::Clusters::Groups;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::Scenes::Id: {
+        using namespace app::Clusters::Scenes;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::OnOff::Id: {
+        using namespace app::Clusters::OnOff;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::OnOffSwitchConfiguration::Id: {
+        using namespace app::Clusters::OnOffSwitchConfiguration;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::LevelControl::Id: {
+        using namespace app::Clusters::LevelControl;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::BinaryInputBasic::Id: {
+        using namespace app::Clusters::BinaryInputBasic;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::Descriptor::Id: {
+        using namespace app::Clusters::Descriptor;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::Binding::Id: {
+        using namespace app::Clusters::Binding;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::AccessControl::Id: {
+        using namespace app::Clusters::AccessControl;
+        switch (aPath.mEventId)
+        {
+        case Events::AccessControlEntryChanged::Id: {
+            Events::AccessControlEntryChanged::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_adminNodeID;
+            if (cppValue.adminNodeID.IsNull())
+            {
+                value_adminNodeID = nullptr;
+            }
+            else
+            {
+                std::string value_adminNodeIDClassName     = "java/lang/Long";
+                std::string value_adminNodeIDCtorSignature = "(J)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(value_adminNodeIDClassName.c_str(),
+                                                                               value_adminNodeIDCtorSignature.c_str(),
+                                                                               cppValue.adminNodeID.Value(), value_adminNodeID);
+            }
+
+            jobject value_adminPasscodeID;
+            if (cppValue.adminPasscodeID.IsNull())
+            {
+                value_adminPasscodeID = nullptr;
+            }
+            else
+            {
+                std::string value_adminPasscodeIDClassName     = "java/lang/Integer";
+                std::string value_adminPasscodeIDCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                    value_adminPasscodeIDClassName.c_str(), value_adminPasscodeIDCtorSignature.c_str(),
+                    cppValue.adminPasscodeID.Value(), value_adminPasscodeID);
+            }
+
+            jobject value_changeType;
+            std::string value_changeTypeClassName     = "java/lang/Integer";
+            std::string value_changeTypeCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_changeTypeClassName.c_str(), value_changeTypeCtorSignature.c_str(), static_cast<uint8_t>(cppValue.changeType),
+                value_changeType);
+
+            jobject value_latestValue;
+            if (cppValue.latestValue.IsNull())
+            {
+                value_latestValue = nullptr;
+            }
+            else
+            {
+                jobject value_latestValue_privilege;
+                std::string value_latestValue_privilegeClassName     = "java/lang/Integer";
+                std::string value_latestValue_privilegeCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    value_latestValue_privilegeClassName.c_str(), value_latestValue_privilegeCtorSignature.c_str(),
+                    static_cast<uint8_t>(cppValue.latestValue.Value().privilege), value_latestValue_privilege);
+                jobject value_latestValue_authMode;
+                std::string value_latestValue_authModeClassName     = "java/lang/Integer";
+                std::string value_latestValue_authModeCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    value_latestValue_authModeClassName.c_str(), value_latestValue_authModeCtorSignature.c_str(),
+                    static_cast<uint8_t>(cppValue.latestValue.Value().authMode), value_latestValue_authMode);
+                jobject value_latestValue_subjects;
+                if (cppValue.latestValue.Value().subjects.IsNull())
+                {
+                    value_latestValue_subjects = nullptr;
+                }
+                else
+                {
+                    chip::JniReferences::GetInstance().CreateArrayList(value_latestValue_subjects);
+
+                    auto iter_value_latestValue_subjects_3 = cppValue.latestValue.Value().subjects.Value().begin();
+                    while (iter_value_latestValue_subjects_3.Next())
+                    {
+                        auto & entry_3 = iter_value_latestValue_subjects_3.GetValue();
+                        jobject newElement_3;
+                        std::string newElement_3ClassName     = "java/lang/Long";
+                        std::string newElement_3CtorSignature = "(J)V";
+                        chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(
+                            newElement_3ClassName.c_str(), newElement_3CtorSignature.c_str(), entry_3, newElement_3);
+                        chip::JniReferences::GetInstance().AddToList(value_latestValue_subjects, newElement_3);
+                    }
+                }
+                jobject value_latestValue_targets;
+                if (cppValue.latestValue.Value().targets.IsNull())
+                {
+                    value_latestValue_targets = nullptr;
+                }
+                else
+                {
+                    chip::JniReferences::GetInstance().CreateArrayList(value_latestValue_targets);
+
+                    auto iter_value_latestValue_targets_3 = cppValue.latestValue.Value().targets.Value().begin();
+                    while (iter_value_latestValue_targets_3.Next())
+                    {
+                        auto & entry_3 = iter_value_latestValue_targets_3.GetValue();
+                        jobject newElement_3;
+                        jobject newElement_3_cluster;
+                        if (entry_3.cluster.IsNull())
+                        {
+                            newElement_3_cluster = nullptr;
+                        }
+                        else
+                        {
+                            std::string newElement_3_clusterClassName     = "java/lang/Long";
+                            std::string newElement_3_clusterCtorSignature = "(J)V";
+                            chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+                                newElement_3_clusterClassName.c_str(), newElement_3_clusterCtorSignature.c_str(),
+                                entry_3.cluster.Value(), newElement_3_cluster);
+                        }
+                        jobject newElement_3_endpoint;
+                        if (entry_3.endpoint.IsNull())
+                        {
+                            newElement_3_endpoint = nullptr;
+                        }
+                        else
+                        {
+                            std::string newElement_3_endpointClassName     = "java/lang/Integer";
+                            std::string newElement_3_endpointCtorSignature = "(I)V";
+                            chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                                newElement_3_endpointClassName.c_str(), newElement_3_endpointCtorSignature.c_str(),
+                                entry_3.endpoint.Value(), newElement_3_endpoint);
+                        }
+                        jobject newElement_3_deviceType;
+                        if (entry_3.deviceType.IsNull())
+                        {
+                            newElement_3_deviceType = nullptr;
+                        }
+                        else
+                        {
+                            std::string newElement_3_deviceTypeClassName     = "java/lang/Long";
+                            std::string newElement_3_deviceTypeCtorSignature = "(J)V";
+                            chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+                                newElement_3_deviceTypeClassName.c_str(), newElement_3_deviceTypeCtorSignature.c_str(),
+                                entry_3.deviceType.Value(), newElement_3_deviceType);
+                        }
+
+                        jclass targetStructClass_4;
+                        err = chip::JniReferences::GetInstance().GetClassRef(
+                            env, "chip/devicecontroller/ChipStructs$AccessControlClusterTarget", targetStructClass_4);
+                        if (err != CHIP_NO_ERROR)
+                        {
+                            ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterTarget");
+                            return nullptr;
+                        }
+                        jmethodID targetStructCtor_4 = env->GetMethodID(targetStructClass_4, "<init>",
+                                                                        "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V");
+                        if (targetStructCtor_4 == nullptr)
+                        {
+                            ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterTarget constructor");
+                            return nullptr;
+                        }
+
+                        newElement_3 = env->NewObject(targetStructClass_4, targetStructCtor_4, newElement_3_cluster,
+                                                      newElement_3_endpoint, newElement_3_deviceType);
+                        chip::JniReferences::GetInstance().AddToList(value_latestValue_targets, newElement_3);
+                    }
+                }
+                jobject value_latestValue_fabricIndex;
+                std::string value_latestValue_fabricIndexClassName     = "java/lang/Integer";
+                std::string value_latestValue_fabricIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    value_latestValue_fabricIndexClassName.c_str(), value_latestValue_fabricIndexCtorSignature.c_str(),
+                    cppValue.latestValue.Value().fabricIndex, value_latestValue_fabricIndex);
+
+                jclass accessControlEntryStructClass_1;
+                err = chip::JniReferences::GetInstance().GetClassRef(
+                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterAccessControlEntry",
+                    accessControlEntryStructClass_1);
+                if (err != CHIP_NO_ERROR)
+                {
+                    ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterAccessControlEntry");
+                    return nullptr;
+                }
+                jmethodID accessControlEntryStructCtor_1 = env->GetMethodID(
+                    accessControlEntryStructClass_1, "<init>",
+                    "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/ArrayList;Ljava/util/ArrayList;Ljava/lang/Integer;)V");
+                if (accessControlEntryStructCtor_1 == nullptr)
+                {
+                    ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterAccessControlEntry constructor");
+                    return nullptr;
+                }
+
+                value_latestValue =
+                    env->NewObject(accessControlEntryStructClass_1, accessControlEntryStructCtor_1, value_latestValue_privilege,
+                                   value_latestValue_authMode, value_latestValue_subjects, value_latestValue_targets,
+                                   value_latestValue_fabricIndex);
+            }
+
+            jobject value_adminFabricIndex;
+            std::string value_adminFabricIndexClassName     = "java/lang/Integer";
+            std::string value_adminFabricIndexCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_adminFabricIndexClassName.c_str(),
+                                                                          value_adminFabricIndexCtorSignature.c_str(),
+                                                                          cppValue.adminFabricIndex, value_adminFabricIndex);
+
+            jclass accessControlEntryChangedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$AccessControlClusterAccessControlEntryChangedEvent",
+                accessControlEntryChangedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$AccessControlClusterAccessControlEntryChangedEvent");
+                return nullptr;
+            }
+            jmethodID accessControlEntryChangedStructCtor =
+                env->GetMethodID(accessControlEntryChangedStructClass, "<init>",
+                                 "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Lchip/devicecontroller/"
+                                 "ChipStructs$AccessControlClusterAccessControlEntry;Ljava/lang/Integer;)V");
+            if (accessControlEntryChangedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$AccessControlClusterAccessControlEntryChangedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(accessControlEntryChangedStructClass, accessControlEntryChangedStructCtor, value_adminNodeID,
+                               value_adminPasscodeID, value_changeType, value_latestValue, value_adminFabricIndex);
+
+            return value;
+        }
+        case Events::AccessControlExtensionChanged::Id: {
+            Events::AccessControlExtensionChanged::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_adminNodeID;
+            if (cppValue.adminNodeID.IsNull())
+            {
+                value_adminNodeID = nullptr;
+            }
+            else
+            {
+                std::string value_adminNodeIDClassName     = "java/lang/Long";
+                std::string value_adminNodeIDCtorSignature = "(J)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(value_adminNodeIDClassName.c_str(),
+                                                                               value_adminNodeIDCtorSignature.c_str(),
+                                                                               cppValue.adminNodeID.Value(), value_adminNodeID);
+            }
+
+            jobject value_adminPasscodeID;
+            if (cppValue.adminPasscodeID.IsNull())
+            {
+                value_adminPasscodeID = nullptr;
+            }
+            else
+            {
+                std::string value_adminPasscodeIDClassName     = "java/lang/Integer";
+                std::string value_adminPasscodeIDCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                    value_adminPasscodeIDClassName.c_str(), value_adminPasscodeIDCtorSignature.c_str(),
+                    cppValue.adminPasscodeID.Value(), value_adminPasscodeID);
+            }
+
+            jobject value_changeType;
+            std::string value_changeTypeClassName     = "java/lang/Integer";
+            std::string value_changeTypeCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_changeTypeClassName.c_str(), value_changeTypeCtorSignature.c_str(), static_cast<uint8_t>(cppValue.changeType),
+                value_changeType);
+
+            jobject value_latestValue;
+            if (cppValue.latestValue.IsNull())
+            {
+                value_latestValue = nullptr;
+            }
+            else
+            {
+                jobject value_latestValue_data;
+                jbyteArray value_latestValue_dataByteArray =
+                    env->NewByteArray(static_cast<jsize>(cppValue.latestValue.Value().data.size()));
+                env->SetByteArrayRegion(value_latestValue_dataByteArray, 0,
+                                        static_cast<jsize>(cppValue.latestValue.Value().data.size()),
+                                        reinterpret_cast<const jbyte *>(cppValue.latestValue.Value().data.data()));
+                value_latestValue_data = value_latestValue_dataByteArray;
+                jobject value_latestValue_fabricIndex;
+                std::string value_latestValue_fabricIndexClassName     = "java/lang/Integer";
+                std::string value_latestValue_fabricIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    value_latestValue_fabricIndexClassName.c_str(), value_latestValue_fabricIndexCtorSignature.c_str(),
+                    cppValue.latestValue.Value().fabricIndex, value_latestValue_fabricIndex);
+
+                jclass extensionEntryStructClass_1;
+                err = chip::JniReferences::GetInstance().GetClassRef(
+                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterExtensionEntry", extensionEntryStructClass_1);
+                if (err != CHIP_NO_ERROR)
+                {
+                    ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterExtensionEntry");
+                    return nullptr;
+                }
+                jmethodID extensionEntryStructCtor_1 =
+                    env->GetMethodID(extensionEntryStructClass_1, "<init>", "([BLjava/lang/Integer;)V");
+                if (extensionEntryStructCtor_1 == nullptr)
+                {
+                    ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterExtensionEntry constructor");
+                    return nullptr;
+                }
+
+                value_latestValue = env->NewObject(extensionEntryStructClass_1, extensionEntryStructCtor_1, value_latestValue_data,
+                                                   value_latestValue_fabricIndex);
+            }
+
+            jobject value_adminFabricIndex;
+            std::string value_adminFabricIndexClassName     = "java/lang/Integer";
+            std::string value_adminFabricIndexCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_adminFabricIndexClassName.c_str(),
+                                                                          value_adminFabricIndexCtorSignature.c_str(),
+                                                                          cppValue.adminFabricIndex, value_adminFabricIndex);
+
+            jclass accessControlExtensionChangedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$AccessControlClusterAccessControlExtensionChangedEvent",
+                accessControlExtensionChangedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$AccessControlClusterAccessControlExtensionChangedEvent");
+                return nullptr;
+            }
+            jmethodID accessControlExtensionChangedStructCtor =
+                env->GetMethodID(accessControlExtensionChangedStructClass, "<init>",
+                                 "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Lchip/devicecontroller/"
+                                 "ChipStructs$AccessControlClusterExtensionEntry;Ljava/lang/Integer;)V");
+            if (accessControlExtensionChangedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$AccessControlClusterAccessControlExtensionChangedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(accessControlExtensionChangedStructClass, accessControlExtensionChangedStructCtor, value_adminNodeID,
+                               value_adminPasscodeID, value_changeType, value_latestValue, value_adminFabricIndex);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::BridgedActions::Id: {
+        using namespace app::Clusters::BridgedActions;
+        switch (aPath.mEventId)
+        {
+        case Events::StateChanged::Id: {
+            Events::StateChanged::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_actionID;
+            std::string value_actionIDClassName     = "java/lang/Integer";
+            std::string value_actionIDCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                value_actionIDClassName.c_str(), value_actionIDCtorSignature.c_str(), cppValue.actionID, value_actionID);
+
+            jobject value_invokeID;
+            std::string value_invokeIDClassName     = "java/lang/Long";
+            std::string value_invokeIDCtorSignature = "(J)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+                value_invokeIDClassName.c_str(), value_invokeIDCtorSignature.c_str(), cppValue.invokeID, value_invokeID);
+
+            jobject value_newState;
+            std::string value_newStateClassName     = "java/lang/Integer";
+            std::string value_newStateCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_newStateClassName.c_str(),
+                                                                          value_newStateCtorSignature.c_str(),
+                                                                          static_cast<uint8_t>(cppValue.newState), value_newState);
+
+            jclass stateChangedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BridgedActionsClusterStateChangedEvent", stateChangedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedActionsClusterStateChangedEvent");
+                return nullptr;
+            }
+            jmethodID stateChangedStructCtor =
+                env->GetMethodID(stateChangedStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Integer;)V");
+            if (stateChangedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedActionsClusterStateChangedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(stateChangedStructClass, stateChangedStructCtor, value_actionID, value_invokeID, value_newState);
+
+            return value;
+        }
+        case Events::ActionFailed::Id: {
+            Events::ActionFailed::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_actionID;
+            std::string value_actionIDClassName     = "java/lang/Integer";
+            std::string value_actionIDCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                value_actionIDClassName.c_str(), value_actionIDCtorSignature.c_str(), cppValue.actionID, value_actionID);
+
+            jobject value_invokeID;
+            std::string value_invokeIDClassName     = "java/lang/Long";
+            std::string value_invokeIDCtorSignature = "(J)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+                value_invokeIDClassName.c_str(), value_invokeIDCtorSignature.c_str(), cppValue.invokeID, value_invokeID);
+
+            jobject value_newState;
+            std::string value_newStateClassName     = "java/lang/Integer";
+            std::string value_newStateCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_newStateClassName.c_str(),
+                                                                          value_newStateCtorSignature.c_str(),
+                                                                          static_cast<uint8_t>(cppValue.newState), value_newState);
+
+            jobject value_error;
+            std::string value_errorClassName     = "java/lang/Integer";
+            std::string value_errorCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_errorClassName.c_str(), value_errorCtorSignature.c_str(), static_cast<uint8_t>(cppValue.error), value_error);
+
+            jclass actionFailedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BridgedActionsClusterActionFailedEvent", actionFailedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedActionsClusterActionFailedEvent");
+                return nullptr;
+            }
+            jmethodID actionFailedStructCtor = env->GetMethodID(
+                actionFailedStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;)V");
+            if (actionFailedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedActionsClusterActionFailedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(actionFailedStructClass, actionFailedStructCtor, value_actionID, value_invokeID,
+                                           value_newState, value_error);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::Basic::Id: {
+        using namespace app::Clusters::Basic;
+        switch (aPath.mEventId)
+        {
+        case Events::StartUp::Id: {
+            Events::StartUp::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_softwareVersion;
+            std::string value_softwareVersionClassName     = "java/lang/Long";
+            std::string value_softwareVersionCtorSignature = "(J)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(value_softwareVersionClassName.c_str(),
+                                                                           value_softwareVersionCtorSignature.c_str(),
+                                                                           cppValue.softwareVersion, value_softwareVersion);
+
+            jclass startUpStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BasicClusterStartUpEvent", startUpStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BasicClusterStartUpEvent");
+                return nullptr;
+            }
+            jmethodID startUpStructCtor = env->GetMethodID(startUpStructClass, "<init>", "(Ljava/lang/Long;)V");
+            if (startUpStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BasicClusterStartUpEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(startUpStructClass, startUpStructCtor, value_softwareVersion);
+
+            return value;
+        }
+        case Events::ShutDown::Id: {
+            Events::ShutDown::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass shutDownStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BasicClusterShutDownEvent", shutDownStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BasicClusterShutDownEvent");
+                return nullptr;
+            }
+            jmethodID shutDownStructCtor = env->GetMethodID(shutDownStructClass, "<init>", "()V");
+            if (shutDownStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BasicClusterShutDownEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(shutDownStructClass, shutDownStructCtor);
+
+            return value;
+        }
+        case Events::Leave::Id: {
+            Events::Leave::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass leaveStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BasicClusterLeaveEvent", leaveStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BasicClusterLeaveEvent");
+                return nullptr;
+            }
+            jmethodID leaveStructCtor = env->GetMethodID(leaveStructClass, "<init>", "()V");
+            if (leaveStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BasicClusterLeaveEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(leaveStructClass, leaveStructCtor);
+
+            return value;
+        }
+        case Events::ReachableChanged::Id: {
+            Events::ReachableChanged::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_reachableNewValue;
+            std::string value_reachableNewValueClassName     = "java/lang/Boolean";
+            std::string value_reachableNewValueCtorSignature = "(Z)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<bool>(value_reachableNewValueClassName.c_str(),
+                                                                       value_reachableNewValueCtorSignature.c_str(),
+                                                                       cppValue.reachableNewValue, value_reachableNewValue);
+
+            jclass reachableChangedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BasicClusterReachableChangedEvent", reachableChangedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BasicClusterReachableChangedEvent");
+                return nullptr;
+            }
+            jmethodID reachableChangedStructCtor =
+                env->GetMethodID(reachableChangedStructClass, "<init>", "(Ljava/lang/Boolean;)V");
+            if (reachableChangedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BasicClusterReachableChangedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(reachableChangedStructClass, reachableChangedStructCtor, value_reachableNewValue);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::OtaSoftwareUpdateProvider::Id: {
+        using namespace app::Clusters::OtaSoftwareUpdateProvider;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::OtaSoftwareUpdateRequestor::Id: {
+        using namespace app::Clusters::OtaSoftwareUpdateRequestor;
+        switch (aPath.mEventId)
+        {
+        case Events::StateTransition::Id: {
+            Events::StateTransition::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_previousState;
+            std::string value_previousStateClassName     = "java/lang/Integer";
+            std::string value_previousStateCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_previousStateClassName.c_str(), value_previousStateCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.previousState), value_previousState);
+
+            jobject value_newState;
+            std::string value_newStateClassName     = "java/lang/Integer";
+            std::string value_newStateCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_newStateClassName.c_str(),
+                                                                          value_newStateCtorSignature.c_str(),
+                                                                          static_cast<uint8_t>(cppValue.newState), value_newState);
+
+            jobject value_reason;
+            std::string value_reasonClassName     = "java/lang/Integer";
+            std::string value_reasonCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_reasonClassName.c_str(),
+                                                                          value_reasonCtorSignature.c_str(),
+                                                                          static_cast<uint8_t>(cppValue.reason), value_reason);
+
+            jobject value_targetSoftwareVersion;
+            if (cppValue.targetSoftwareVersion.IsNull())
+            {
+                value_targetSoftwareVersion = nullptr;
+            }
+            else
+            {
+                std::string value_targetSoftwareVersionClassName     = "java/lang/Long";
+                std::string value_targetSoftwareVersionCtorSignature = "(J)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+                    value_targetSoftwareVersionClassName.c_str(), value_targetSoftwareVersionCtorSignature.c_str(),
+                    cppValue.targetSoftwareVersion.Value(), value_targetSoftwareVersion);
+            }
+
+            jclass stateTransitionStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$OtaSoftwareUpdateRequestorClusterStateTransitionEvent",
+                stateTransitionStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$OtaSoftwareUpdateRequestorClusterStateTransitionEvent");
+                return nullptr;
+            }
+            jmethodID stateTransitionStructCtor =
+                env->GetMethodID(stateTransitionStructClass, "<init>",
+                                 "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Long;)V");
+            if (stateTransitionStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$OtaSoftwareUpdateRequestorClusterStateTransitionEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(stateTransitionStructClass, stateTransitionStructCtor, value_previousState,
+                                           value_newState, value_reason, value_targetSoftwareVersion);
+
+            return value;
+        }
+        case Events::VersionApplied::Id: {
+            Events::VersionApplied::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_softwareVersion;
+            std::string value_softwareVersionClassName     = "java/lang/Long";
+            std::string value_softwareVersionCtorSignature = "(J)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(value_softwareVersionClassName.c_str(),
+                                                                           value_softwareVersionCtorSignature.c_str(),
+                                                                           cppValue.softwareVersion, value_softwareVersion);
+
+            jobject value_productID;
+            std::string value_productIDClassName     = "java/lang/Integer";
+            std::string value_productIDCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                value_productIDClassName.c_str(), value_productIDCtorSignature.c_str(), cppValue.productID, value_productID);
+
+            jclass versionAppliedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$OtaSoftwareUpdateRequestorClusterVersionAppliedEvent",
+                versionAppliedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$OtaSoftwareUpdateRequestorClusterVersionAppliedEvent");
+                return nullptr;
+            }
+            jmethodID versionAppliedStructCtor =
+                env->GetMethodID(versionAppliedStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;)V");
+            if (versionAppliedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$OtaSoftwareUpdateRequestorClusterVersionAppliedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(versionAppliedStructClass, versionAppliedStructCtor, value_softwareVersion, value_productID);
+
+            return value;
+        }
+        case Events::DownloadError::Id: {
+            Events::DownloadError::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_softwareVersion;
+            std::string value_softwareVersionClassName     = "java/lang/Long";
+            std::string value_softwareVersionCtorSignature = "(J)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(value_softwareVersionClassName.c_str(),
+                                                                           value_softwareVersionCtorSignature.c_str(),
+                                                                           cppValue.softwareVersion, value_softwareVersion);
+
+            jobject value_bytesDownloaded;
+            std::string value_bytesDownloadedClassName     = "java/lang/Long";
+            std::string value_bytesDownloadedCtorSignature = "(J)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(value_bytesDownloadedClassName.c_str(),
+                                                                           value_bytesDownloadedCtorSignature.c_str(),
+                                                                           cppValue.bytesDownloaded, value_bytesDownloaded);
+
+            jobject value_progressPercent;
+            if (cppValue.progressPercent.IsNull())
+            {
+                value_progressPercent = nullptr;
+            }
+            else
+            {
+                std::string value_progressPercentClassName     = "java/lang/Integer";
+                std::string value_progressPercentCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    value_progressPercentClassName.c_str(), value_progressPercentCtorSignature.c_str(),
+                    cppValue.progressPercent.Value(), value_progressPercent);
+            }
+
+            jobject value_platformCode;
+            if (cppValue.platformCode.IsNull())
+            {
+                value_platformCode = nullptr;
+            }
+            else
+            {
+                std::string value_platformCodeClassName     = "java/lang/Long";
+                std::string value_platformCodeCtorSignature = "(J)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<int64_t>(value_platformCodeClassName.c_str(),
+                                                                              value_platformCodeCtorSignature.c_str(),
+                                                                              cppValue.platformCode.Value(), value_platformCode);
+            }
+
+            jclass downloadErrorStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$OtaSoftwareUpdateRequestorClusterDownloadErrorEvent",
+                downloadErrorStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$OtaSoftwareUpdateRequestorClusterDownloadErrorEvent");
+                return nullptr;
+            }
+            jmethodID downloadErrorStructCtor = env->GetMethodID(
+                downloadErrorStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V");
+            if (downloadErrorStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$OtaSoftwareUpdateRequestorClusterDownloadErrorEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(downloadErrorStructClass, downloadErrorStructCtor, value_softwareVersion,
+                                           value_bytesDownloaded, value_progressPercent, value_platformCode);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::LocalizationConfiguration::Id: {
+        using namespace app::Clusters::LocalizationConfiguration;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::TimeFormatLocalization::Id: {
+        using namespace app::Clusters::TimeFormatLocalization;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::UnitLocalization::Id: {
+        using namespace app::Clusters::UnitLocalization;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::PowerSourceConfiguration::Id: {
+        using namespace app::Clusters::PowerSourceConfiguration;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::PowerSource::Id: {
+        using namespace app::Clusters::PowerSource;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::GeneralCommissioning::Id: {
+        using namespace app::Clusters::GeneralCommissioning;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::NetworkCommissioning::Id: {
+        using namespace app::Clusters::NetworkCommissioning;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::DiagnosticLogs::Id: {
+        using namespace app::Clusters::DiagnosticLogs;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::GeneralDiagnostics::Id: {
+        using namespace app::Clusters::GeneralDiagnostics;
+        switch (aPath.mEventId)
+        {
+        case Events::HardwareFaultChange::Id: {
+            Events::HardwareFaultChange::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_current;
+            chip::JniReferences::GetInstance().CreateArrayList(value_current);
+
+            auto iter_value_current_0 = cppValue.current.begin();
+            while (iter_value_current_0.Next())
+            {
+                auto & entry_0 = iter_value_current_0.GetValue();
+                jobject newElement_0;
+                std::string newElement_0ClassName     = "java/lang/Integer";
+                std::string newElement_0CtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), static_cast<uint8_t>(entry_0), newElement_0);
+                chip::JniReferences::GetInstance().AddToList(value_current, newElement_0);
+            }
+
+            jobject value_previous;
+            chip::JniReferences::GetInstance().CreateArrayList(value_previous);
+
+            auto iter_value_previous_0 = cppValue.previous.begin();
+            while (iter_value_previous_0.Next())
+            {
+                auto & entry_0 = iter_value_previous_0.GetValue();
+                jobject newElement_0;
+                std::string newElement_0ClassName     = "java/lang/Integer";
+                std::string newElement_0CtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), static_cast<uint8_t>(entry_0), newElement_0);
+                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
+            }
+
+            jclass hardwareFaultChangeStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$GeneralDiagnosticsClusterHardwareFaultChangeEvent",
+                hardwareFaultChangeStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$GeneralDiagnosticsClusterHardwareFaultChangeEvent");
+                return nullptr;
+            }
+            jmethodID hardwareFaultChangeStructCtor =
+                env->GetMethodID(hardwareFaultChangeStructClass, "<init>", "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V");
+            if (hardwareFaultChangeStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$GeneralDiagnosticsClusterHardwareFaultChangeEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(hardwareFaultChangeStructClass, hardwareFaultChangeStructCtor, value_current, value_previous);
+
+            return value;
+        }
+        case Events::RadioFaultChange::Id: {
+            Events::RadioFaultChange::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_current;
+            chip::JniReferences::GetInstance().CreateArrayList(value_current);
+
+            auto iter_value_current_0 = cppValue.current.begin();
+            while (iter_value_current_0.Next())
+            {
+                auto & entry_0 = iter_value_current_0.GetValue();
+                jobject newElement_0;
+                std::string newElement_0ClassName     = "java/lang/Integer";
+                std::string newElement_0CtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), static_cast<uint8_t>(entry_0), newElement_0);
+                chip::JniReferences::GetInstance().AddToList(value_current, newElement_0);
+            }
+
+            jobject value_previous;
+            chip::JniReferences::GetInstance().CreateArrayList(value_previous);
+
+            auto iter_value_previous_0 = cppValue.previous.begin();
+            while (iter_value_previous_0.Next())
+            {
+                auto & entry_0 = iter_value_previous_0.GetValue();
+                jobject newElement_0;
+                std::string newElement_0ClassName     = "java/lang/Integer";
+                std::string newElement_0CtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), static_cast<uint8_t>(entry_0), newElement_0);
+                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
+            }
+
+            jclass radioFaultChangeStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$GeneralDiagnosticsClusterRadioFaultChangeEvent",
+                radioFaultChangeStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$GeneralDiagnosticsClusterRadioFaultChangeEvent");
+                return nullptr;
+            }
+            jmethodID radioFaultChangeStructCtor =
+                env->GetMethodID(radioFaultChangeStructClass, "<init>", "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V");
+            if (radioFaultChangeStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$GeneralDiagnosticsClusterRadioFaultChangeEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(radioFaultChangeStructClass, radioFaultChangeStructCtor, value_current, value_previous);
+
+            return value;
+        }
+        case Events::NetworkFaultChange::Id: {
+            Events::NetworkFaultChange::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_current;
+            chip::JniReferences::GetInstance().CreateArrayList(value_current);
+
+            auto iter_value_current_0 = cppValue.current.begin();
+            while (iter_value_current_0.Next())
+            {
+                auto & entry_0 = iter_value_current_0.GetValue();
+                jobject newElement_0;
+                std::string newElement_0ClassName     = "java/lang/Integer";
+                std::string newElement_0CtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), static_cast<uint8_t>(entry_0), newElement_0);
+                chip::JniReferences::GetInstance().AddToList(value_current, newElement_0);
+            }
+
+            jobject value_previous;
+            chip::JniReferences::GetInstance().CreateArrayList(value_previous);
+
+            auto iter_value_previous_0 = cppValue.previous.begin();
+            while (iter_value_previous_0.Next())
+            {
+                auto & entry_0 = iter_value_previous_0.GetValue();
+                jobject newElement_0;
+                std::string newElement_0ClassName     = "java/lang/Integer";
+                std::string newElement_0CtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), static_cast<uint8_t>(entry_0), newElement_0);
+                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
+            }
+
+            jclass networkFaultChangeStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$GeneralDiagnosticsClusterNetworkFaultChangeEvent",
+                networkFaultChangeStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$GeneralDiagnosticsClusterNetworkFaultChangeEvent");
+                return nullptr;
+            }
+            jmethodID networkFaultChangeStructCtor =
+                env->GetMethodID(networkFaultChangeStructClass, "<init>", "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V");
+            if (networkFaultChangeStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$GeneralDiagnosticsClusterNetworkFaultChangeEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(networkFaultChangeStructClass, networkFaultChangeStructCtor, value_current, value_previous);
+
+            return value;
+        }
+        case Events::BootReason::Id: {
+            Events::BootReason::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_bootReason;
+            std::string value_bootReasonClassName     = "java/lang/Integer";
+            std::string value_bootReasonCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_bootReasonClassName.c_str(), value_bootReasonCtorSignature.c_str(), static_cast<uint8_t>(cppValue.bootReason),
+                value_bootReason);
+
+            jclass bootReasonStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$GeneralDiagnosticsClusterBootReasonEvent", bootReasonStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$GeneralDiagnosticsClusterBootReasonEvent");
+                return nullptr;
+            }
+            jmethodID bootReasonStructCtor = env->GetMethodID(bootReasonStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (bootReasonStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$GeneralDiagnosticsClusterBootReasonEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(bootReasonStructClass, bootReasonStructCtor, value_bootReason);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::SoftwareDiagnostics::Id: {
+        using namespace app::Clusters::SoftwareDiagnostics;
+        switch (aPath.mEventId)
+        {
+        case Events::SoftwareFault::Id: {
+            Events::SoftwareFault::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_id;
+            std::string value_idClassName     = "java/lang/Long";
+            std::string value_idCtorSignature = "(J)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(value_idClassName.c_str(), value_idCtorSignature.c_str(),
+                                                                           cppValue.id, value_id);
+
+            jobject value_name;
+            if (!cppValue.name.HasValue())
+            {
+                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_name);
+            }
+            else
+            {
+                jobject value_nameInsideOptional;
+                value_nameInsideOptional =
+                    env->NewStringUTF(std::string(cppValue.name.Value().data(), cppValue.name.Value().size()).c_str());
+                chip::JniReferences::GetInstance().CreateOptional(value_nameInsideOptional, value_name);
+            }
+
+            jobject value_faultRecording;
+            if (!cppValue.faultRecording.HasValue())
+            {
+                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_faultRecording);
+            }
+            else
+            {
+                jobject value_faultRecordingInsideOptional;
+                jbyteArray value_faultRecordingInsideOptionalByteArray =
+                    env->NewByteArray(static_cast<jsize>(cppValue.faultRecording.Value().size()));
+                env->SetByteArrayRegion(value_faultRecordingInsideOptionalByteArray, 0,
+                                        static_cast<jsize>(cppValue.faultRecording.Value().size()),
+                                        reinterpret_cast<const jbyte *>(cppValue.faultRecording.Value().data()));
+                value_faultRecordingInsideOptional = value_faultRecordingInsideOptionalByteArray;
+                chip::JniReferences::GetInstance().CreateOptional(value_faultRecordingInsideOptional, value_faultRecording);
+            }
+
+            jclass softwareFaultStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$SoftwareDiagnosticsClusterSoftwareFaultEvent",
+                softwareFaultStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$SoftwareDiagnosticsClusterSoftwareFaultEvent");
+                return nullptr;
+            }
+            jmethodID softwareFaultStructCtor =
+                env->GetMethodID(softwareFaultStructClass, "<init>", "(Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;)V");
+            if (softwareFaultStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$SoftwareDiagnosticsClusterSoftwareFaultEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(softwareFaultStructClass, softwareFaultStructCtor, value_id, value_name, value_faultRecording);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::ThreadNetworkDiagnostics::Id: {
+        using namespace app::Clusters::ThreadNetworkDiagnostics;
+        switch (aPath.mEventId)
+        {
+        case Events::ConnectionStatus::Id: {
+            Events::ConnectionStatus::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_connectionStatus;
+            std::string value_connectionStatusClassName     = "java/lang/Integer";
+            std::string value_connectionStatusCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_connectionStatusClassName.c_str(), value_connectionStatusCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.connectionStatus), value_connectionStatus);
+
+            jclass connectionStatusStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$ThreadNetworkDiagnosticsClusterConnectionStatusEvent",
+                connectionStatusStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$ThreadNetworkDiagnosticsClusterConnectionStatusEvent");
+                return nullptr;
+            }
+            jmethodID connectionStatusStructCtor =
+                env->GetMethodID(connectionStatusStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (connectionStatusStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$ThreadNetworkDiagnosticsClusterConnectionStatusEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(connectionStatusStructClass, connectionStatusStructCtor, value_connectionStatus);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::WiFiNetworkDiagnostics::Id: {
+        using namespace app::Clusters::WiFiNetworkDiagnostics;
+        switch (aPath.mEventId)
+        {
+        case Events::Disconnection::Id: {
+            Events::Disconnection::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_reasonCode;
+            std::string value_reasonCodeClassName     = "java/lang/Integer";
+            std::string value_reasonCodeCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                value_reasonCodeClassName.c_str(), value_reasonCodeCtorSignature.c_str(), cppValue.reasonCode, value_reasonCode);
+
+            jclass disconnectionStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$WiFiNetworkDiagnosticsClusterDisconnectionEvent",
+                disconnectionStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$WiFiNetworkDiagnosticsClusterDisconnectionEvent");
+                return nullptr;
+            }
+            jmethodID disconnectionStructCtor = env->GetMethodID(disconnectionStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (disconnectionStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$WiFiNetworkDiagnosticsClusterDisconnectionEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(disconnectionStructClass, disconnectionStructCtor, value_reasonCode);
+
+            return value;
+        }
+        case Events::AssociationFailure::Id: {
+            Events::AssociationFailure::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_associationFailure;
+            std::string value_associationFailureClassName     = "java/lang/Integer";
+            std::string value_associationFailureCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_associationFailureClassName.c_str(), value_associationFailureCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.associationFailure), value_associationFailure);
+
+            jobject value_status;
+            std::string value_statusClassName     = "java/lang/Integer";
+            std::string value_statusCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                value_statusClassName.c_str(), value_statusCtorSignature.c_str(), cppValue.status, value_status);
+
+            jclass associationFailureStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$WiFiNetworkDiagnosticsClusterAssociationFailureEvent",
+                associationFailureStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$WiFiNetworkDiagnosticsClusterAssociationFailureEvent");
+                return nullptr;
+            }
+            jmethodID associationFailureStructCtor =
+                env->GetMethodID(associationFailureStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+            if (associationFailureStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$WiFiNetworkDiagnosticsClusterAssociationFailureEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(associationFailureStructClass, associationFailureStructCtor, value_associationFailure, value_status);
+
+            return value;
+        }
+        case Events::ConnectionStatus::Id: {
+            Events::ConnectionStatus::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_connectionStatus;
+            std::string value_connectionStatusClassName     = "java/lang/Integer";
+            std::string value_connectionStatusCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_connectionStatusClassName.c_str(), value_connectionStatusCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.connectionStatus), value_connectionStatus);
+
+            jclass connectionStatusStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$WiFiNetworkDiagnosticsClusterConnectionStatusEvent",
+                connectionStatusStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$WiFiNetworkDiagnosticsClusterConnectionStatusEvent");
+                return nullptr;
+            }
+            jmethodID connectionStatusStructCtor =
+                env->GetMethodID(connectionStatusStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (connectionStatusStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$WiFiNetworkDiagnosticsClusterConnectionStatusEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(connectionStatusStructClass, connectionStatusStructCtor, value_connectionStatus);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::EthernetNetworkDiagnostics::Id: {
+        using namespace app::Clusters::EthernetNetworkDiagnostics;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::BridgedDeviceBasic::Id: {
+        using namespace app::Clusters::BridgedDeviceBasic;
+        switch (aPath.mEventId)
+        {
+        case Events::StartUp::Id: {
+            Events::StartUp::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_softwareVersion;
+            std::string value_softwareVersionClassName     = "java/lang/Long";
+            std::string value_softwareVersionCtorSignature = "(J)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(value_softwareVersionClassName.c_str(),
+                                                                           value_softwareVersionCtorSignature.c_str(),
+                                                                           cppValue.softwareVersion, value_softwareVersion);
+
+            jclass startUpStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BridgedDeviceBasicClusterStartUpEvent", startUpStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedDeviceBasicClusterStartUpEvent");
+                return nullptr;
+            }
+            jmethodID startUpStructCtor = env->GetMethodID(startUpStructClass, "<init>", "(Ljava/lang/Long;)V");
+            if (startUpStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedDeviceBasicClusterStartUpEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(startUpStructClass, startUpStructCtor, value_softwareVersion);
+
+            return value;
+        }
+        case Events::ShutDown::Id: {
+            Events::ShutDown::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass shutDownStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BridgedDeviceBasicClusterShutDownEvent", shutDownStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedDeviceBasicClusterShutDownEvent");
+                return nullptr;
+            }
+            jmethodID shutDownStructCtor = env->GetMethodID(shutDownStructClass, "<init>", "()V");
+            if (shutDownStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedDeviceBasicClusterShutDownEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(shutDownStructClass, shutDownStructCtor);
+
+            return value;
+        }
+        case Events::Leave::Id: {
+            Events::Leave::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass leaveStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BridgedDeviceBasicClusterLeaveEvent", leaveStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedDeviceBasicClusterLeaveEvent");
+                return nullptr;
+            }
+            jmethodID leaveStructCtor = env->GetMethodID(leaveStructClass, "<init>", "()V");
+            if (leaveStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedDeviceBasicClusterLeaveEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(leaveStructClass, leaveStructCtor);
+
+            return value;
+        }
+        case Events::ReachableChanged::Id: {
+            Events::ReachableChanged::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_reachableNewValue;
+            std::string value_reachableNewValueClassName     = "java/lang/Boolean";
+            std::string value_reachableNewValueCtorSignature = "(Z)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<bool>(value_reachableNewValueClassName.c_str(),
+                                                                       value_reachableNewValueCtorSignature.c_str(),
+                                                                       cppValue.reachableNewValue, value_reachableNewValue);
+
+            jclass reachableChangedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BridgedDeviceBasicClusterReachableChangedEvent",
+                reachableChangedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedDeviceBasicClusterReachableChangedEvent");
+                return nullptr;
+            }
+            jmethodID reachableChangedStructCtor =
+                env->GetMethodID(reachableChangedStructClass, "<init>", "(Ljava/lang/Boolean;)V");
+            if (reachableChangedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedDeviceBasicClusterReachableChangedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(reachableChangedStructClass, reachableChangedStructCtor, value_reachableNewValue);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::Switch::Id: {
+        using namespace app::Clusters::Switch;
+        switch (aPath.mEventId)
+        {
+        case Events::SwitchLatched::Id: {
+            Events::SwitchLatched::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_newPosition;
+            std::string value_newPositionClassName     = "java/lang/Integer";
+            std::string value_newPositionCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_newPositionClassName.c_str(),
+                                                                          value_newPositionCtorSignature.c_str(),
+                                                                          cppValue.newPosition, value_newPosition);
+
+            jclass switchLatchedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterSwitchLatchedEvent", switchLatchedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterSwitchLatchedEvent");
+                return nullptr;
+            }
+            jmethodID switchLatchedStructCtor = env->GetMethodID(switchLatchedStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (switchLatchedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$SwitchClusterSwitchLatchedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(switchLatchedStructClass, switchLatchedStructCtor, value_newPosition);
+
+            return value;
+        }
+        case Events::InitialPress::Id: {
+            Events::InitialPress::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_newPosition;
+            std::string value_newPositionClassName     = "java/lang/Integer";
+            std::string value_newPositionCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_newPositionClassName.c_str(),
+                                                                          value_newPositionCtorSignature.c_str(),
+                                                                          cppValue.newPosition, value_newPosition);
+
+            jclass initialPressStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterInitialPressEvent", initialPressStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterInitialPressEvent");
+                return nullptr;
+            }
+            jmethodID initialPressStructCtor = env->GetMethodID(initialPressStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (initialPressStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$SwitchClusterInitialPressEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(initialPressStructClass, initialPressStructCtor, value_newPosition);
+
+            return value;
+        }
+        case Events::LongPress::Id: {
+            Events::LongPress::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_newPosition;
+            std::string value_newPositionClassName     = "java/lang/Integer";
+            std::string value_newPositionCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_newPositionClassName.c_str(),
+                                                                          value_newPositionCtorSignature.c_str(),
+                                                                          cppValue.newPosition, value_newPosition);
+
+            jclass longPressStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterLongPressEvent", longPressStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterLongPressEvent");
+                return nullptr;
+            }
+            jmethodID longPressStructCtor = env->GetMethodID(longPressStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (longPressStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$SwitchClusterLongPressEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(longPressStructClass, longPressStructCtor, value_newPosition);
+
+            return value;
+        }
+        case Events::ShortRelease::Id: {
+            Events::ShortRelease::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_previousPosition;
+            std::string value_previousPositionClassName     = "java/lang/Integer";
+            std::string value_previousPositionCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_previousPositionClassName.c_str(),
+                                                                          value_previousPositionCtorSignature.c_str(),
+                                                                          cppValue.previousPosition, value_previousPosition);
+
+            jclass shortReleaseStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterShortReleaseEvent", shortReleaseStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterShortReleaseEvent");
+                return nullptr;
+            }
+            jmethodID shortReleaseStructCtor = env->GetMethodID(shortReleaseStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (shortReleaseStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$SwitchClusterShortReleaseEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(shortReleaseStructClass, shortReleaseStructCtor, value_previousPosition);
+
+            return value;
+        }
+        case Events::LongRelease::Id: {
+            Events::LongRelease::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_previousPosition;
+            std::string value_previousPositionClassName     = "java/lang/Integer";
+            std::string value_previousPositionCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_previousPositionClassName.c_str(),
+                                                                          value_previousPositionCtorSignature.c_str(),
+                                                                          cppValue.previousPosition, value_previousPosition);
+
+            jclass longReleaseStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterLongReleaseEvent", longReleaseStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterLongReleaseEvent");
+                return nullptr;
+            }
+            jmethodID longReleaseStructCtor = env->GetMethodID(longReleaseStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (longReleaseStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$SwitchClusterLongReleaseEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(longReleaseStructClass, longReleaseStructCtor, value_previousPosition);
+
+            return value;
+        }
+        case Events::MultiPressOngoing::Id: {
+            Events::MultiPressOngoing::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_newPosition;
+            std::string value_newPositionClassName     = "java/lang/Integer";
+            std::string value_newPositionCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_newPositionClassName.c_str(),
+                                                                          value_newPositionCtorSignature.c_str(),
+                                                                          cppValue.newPosition, value_newPosition);
+
+            jobject value_currentNumberOfPressesCounted;
+            std::string value_currentNumberOfPressesCountedClassName     = "java/lang/Integer";
+            std::string value_currentNumberOfPressesCountedCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_currentNumberOfPressesCountedClassName.c_str(), value_currentNumberOfPressesCountedCtorSignature.c_str(),
+                cppValue.currentNumberOfPressesCounted, value_currentNumberOfPressesCounted);
+
+            jclass multiPressOngoingStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterMultiPressOngoingEvent", multiPressOngoingStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterMultiPressOngoingEvent");
+                return nullptr;
+            }
+            jmethodID multiPressOngoingStructCtor =
+                env->GetMethodID(multiPressOngoingStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+            if (multiPressOngoingStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$SwitchClusterMultiPressOngoingEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(multiPressOngoingStructClass, multiPressOngoingStructCtor, value_newPosition,
+                                           value_currentNumberOfPressesCounted);
+
+            return value;
+        }
+        case Events::MultiPressComplete::Id: {
+            Events::MultiPressComplete::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_newPosition;
+            std::string value_newPositionClassName     = "java/lang/Integer";
+            std::string value_newPositionCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_newPositionClassName.c_str(),
+                                                                          value_newPositionCtorSignature.c_str(),
+                                                                          cppValue.newPosition, value_newPosition);
+
+            jobject value_totalNumberOfPressesCounted;
+            std::string value_totalNumberOfPressesCountedClassName     = "java/lang/Integer";
+            std::string value_totalNumberOfPressesCountedCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_totalNumberOfPressesCountedClassName.c_str(), value_totalNumberOfPressesCountedCtorSignature.c_str(),
+                cppValue.totalNumberOfPressesCounted, value_totalNumberOfPressesCounted);
+
+            jclass multiPressCompleteStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterMultiPressCompleteEvent", multiPressCompleteStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterMultiPressCompleteEvent");
+                return nullptr;
+            }
+            jmethodID multiPressCompleteStructCtor =
+                env->GetMethodID(multiPressCompleteStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+            if (multiPressCompleteStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$SwitchClusterMultiPressCompleteEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(multiPressCompleteStructClass, multiPressCompleteStructCtor, value_newPosition,
+                                           value_totalNumberOfPressesCounted);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::AdministratorCommissioning::Id: {
+        using namespace app::Clusters::AdministratorCommissioning;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::OperationalCredentials::Id: {
+        using namespace app::Clusters::OperationalCredentials;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::GroupKeyManagement::Id: {
+        using namespace app::Clusters::GroupKeyManagement;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::FixedLabel::Id: {
+        using namespace app::Clusters::FixedLabel;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::UserLabel::Id: {
+        using namespace app::Clusters::UserLabel;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::BooleanState::Id: {
+        using namespace app::Clusters::BooleanState;
+        switch (aPath.mEventId)
+        {
+        case Events::StateChange::Id: {
+            Events::StateChange::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_stateValue;
+            std::string value_stateValueClassName     = "java/lang/Boolean";
+            std::string value_stateValueCtorSignature = "(Z)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<bool>(
+                value_stateValueClassName.c_str(), value_stateValueCtorSignature.c_str(), cppValue.stateValue, value_stateValue);
+
+            jclass stateChangeStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$BooleanStateClusterStateChangeEvent", stateChangeStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$BooleanStateClusterStateChangeEvent");
+                return nullptr;
+            }
+            jmethodID stateChangeStructCtor = env->GetMethodID(stateChangeStructClass, "<init>", "(Ljava/lang/Boolean;)V");
+            if (stateChangeStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$BooleanStateClusterStateChangeEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(stateChangeStructClass, stateChangeStructCtor, value_stateValue);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::ModeSelect::Id: {
+        using namespace app::Clusters::ModeSelect;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::DoorLock::Id: {
+        using namespace app::Clusters::DoorLock;
+        switch (aPath.mEventId)
+        {
+        case Events::DoorLockAlarm::Id: {
+            Events::DoorLockAlarm::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_alarmCode;
+            std::string value_alarmCodeClassName     = "java/lang/Integer";
+            std::string value_alarmCodeCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_alarmCodeClassName.c_str(), value_alarmCodeCtorSignature.c_str(), static_cast<uint8_t>(cppValue.alarmCode),
+                value_alarmCode);
+
+            jclass doorLockAlarmStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterDoorLockAlarmEvent", doorLockAlarmStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterDoorLockAlarmEvent");
+                return nullptr;
+            }
+            jmethodID doorLockAlarmStructCtor = env->GetMethodID(doorLockAlarmStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (doorLockAlarmStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$DoorLockClusterDoorLockAlarmEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(doorLockAlarmStructClass, doorLockAlarmStructCtor, value_alarmCode);
+
+            return value;
+        }
+        case Events::DoorStateChange::Id: {
+            Events::DoorStateChange::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_doorState;
+            std::string value_doorStateClassName     = "java/lang/Integer";
+            std::string value_doorStateCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_doorStateClassName.c_str(), value_doorStateCtorSignature.c_str(), static_cast<uint8_t>(cppValue.doorState),
+                value_doorState);
+
+            jclass doorStateChangeStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterDoorStateChangeEvent", doorStateChangeStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterDoorStateChangeEvent");
+                return nullptr;
+            }
+            jmethodID doorStateChangeStructCtor = env->GetMethodID(doorStateChangeStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (doorStateChangeStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$DoorLockClusterDoorStateChangeEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(doorStateChangeStructClass, doorStateChangeStructCtor, value_doorState);
+
+            return value;
+        }
+        case Events::LockOperation::Id: {
+            Events::LockOperation::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_lockOperationType;
+            std::string value_lockOperationTypeClassName     = "java/lang/Integer";
+            std::string value_lockOperationTypeCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_lockOperationTypeClassName.c_str(), value_lockOperationTypeCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.lockOperationType), value_lockOperationType);
+
+            jobject value_operationSource;
+            std::string value_operationSourceClassName     = "java/lang/Integer";
+            std::string value_operationSourceCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_operationSourceClassName.c_str(), value_operationSourceCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.operationSource), value_operationSource);
+
+            jobject value_userIndex;
+            if (cppValue.userIndex.IsNull())
+            {
+                value_userIndex = nullptr;
+            }
+            else
+            {
+                std::string value_userIndexClassName     = "java/lang/Integer";
+                std::string value_userIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(value_userIndexClassName.c_str(),
+                                                                               value_userIndexCtorSignature.c_str(),
+                                                                               cppValue.userIndex.Value(), value_userIndex);
+            }
+
+            jobject value_fabricIndex;
+            if (cppValue.fabricIndex.IsNull())
+            {
+                value_fabricIndex = nullptr;
+            }
+            else
+            {
+                std::string value_fabricIndexClassName     = "java/lang/Integer";
+                std::string value_fabricIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_fabricIndexClassName.c_str(),
+                                                                              value_fabricIndexCtorSignature.c_str(),
+                                                                              cppValue.fabricIndex.Value(), value_fabricIndex);
+            }
+
+            jobject value_sourceNode;
+            if (cppValue.sourceNode.IsNull())
+            {
+                value_sourceNode = nullptr;
+            }
+            else
+            {
+                std::string value_sourceNodeClassName     = "java/lang/Long";
+                std::string value_sourceNodeCtorSignature = "(J)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(value_sourceNodeClassName.c_str(),
+                                                                               value_sourceNodeCtorSignature.c_str(),
+                                                                               cppValue.sourceNode.Value(), value_sourceNode);
+            }
+
+            jobject value_credentials;
+            if (!cppValue.credentials.HasValue())
+            {
+                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_credentials);
+            }
+            else
+            {
+                jobject value_credentialsInsideOptional;
+                if (cppValue.credentials.Value().IsNull())
+                {
+                    value_credentialsInsideOptional = nullptr;
+                }
+                else
+                {
+                    chip::JniReferences::GetInstance().CreateArrayList(value_credentialsInsideOptional);
+
+                    auto iter_value_credentialsInsideOptional_2 = cppValue.credentials.Value().Value().begin();
+                    while (iter_value_credentialsInsideOptional_2.Next())
+                    {
+                        auto & entry_2 = iter_value_credentialsInsideOptional_2.GetValue();
+                        jobject newElement_2;
+                        jobject newElement_2_credentialType;
+                        std::string newElement_2_credentialTypeClassName     = "java/lang/Integer";
+                        std::string newElement_2_credentialTypeCtorSignature = "(I)V";
+                        chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                            newElement_2_credentialTypeClassName.c_str(), newElement_2_credentialTypeCtorSignature.c_str(),
+                            static_cast<uint8_t>(entry_2.credentialType), newElement_2_credentialType);
+                        jobject newElement_2_credentialIndex;
+                        std::string newElement_2_credentialIndexClassName     = "java/lang/Integer";
+                        std::string newElement_2_credentialIndexCtorSignature = "(I)V";
+                        chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                            newElement_2_credentialIndexClassName.c_str(), newElement_2_credentialIndexCtorSignature.c_str(),
+                            entry_2.credentialIndex, newElement_2_credentialIndex);
+
+                        jclass dlCredentialStructClass_3;
+                        err = chip::JniReferences::GetInstance().GetClassRef(
+                            env, "chip/devicecontroller/ChipStructs$DoorLockClusterDlCredential", dlCredentialStructClass_3);
+                        if (err != CHIP_NO_ERROR)
+                        {
+                            ChipLogError(Zcl, "Could not find class ChipStructs$DoorLockClusterDlCredential");
+                            return nullptr;
+                        }
+                        jmethodID dlCredentialStructCtor_3 =
+                            env->GetMethodID(dlCredentialStructClass_3, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+                        if (dlCredentialStructCtor_3 == nullptr)
+                        {
+                            ChipLogError(Zcl, "Could not find ChipStructs$DoorLockClusterDlCredential constructor");
+                            return nullptr;
+                        }
+
+                        newElement_2 = env->NewObject(dlCredentialStructClass_3, dlCredentialStructCtor_3,
+                                                      newElement_2_credentialType, newElement_2_credentialIndex);
+                        chip::JniReferences::GetInstance().AddToList(value_credentialsInsideOptional, newElement_2);
+                    }
+                }
+                chip::JniReferences::GetInstance().CreateOptional(value_credentialsInsideOptional, value_credentials);
+            }
+
+            jclass lockOperationStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterLockOperationEvent", lockOperationStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterLockOperationEvent");
+                return nullptr;
+            }
+            jmethodID lockOperationStructCtor = env->GetMethodID(lockOperationStructClass, "<init>",
+                                                                 "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/"
+                                                                 "lang/Integer;Ljava/lang/Long;Ljava/util/Optional;)V");
+            if (lockOperationStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$DoorLockClusterLockOperationEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(lockOperationStructClass, lockOperationStructCtor, value_lockOperationType, value_operationSource,
+                               value_userIndex, value_fabricIndex, value_sourceNode, value_credentials);
+
+            return value;
+        }
+        case Events::LockOperationError::Id: {
+            Events::LockOperationError::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_lockOperationType;
+            std::string value_lockOperationTypeClassName     = "java/lang/Integer";
+            std::string value_lockOperationTypeCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_lockOperationTypeClassName.c_str(), value_lockOperationTypeCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.lockOperationType), value_lockOperationType);
+
+            jobject value_operationSource;
+            std::string value_operationSourceClassName     = "java/lang/Integer";
+            std::string value_operationSourceCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_operationSourceClassName.c_str(), value_operationSourceCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.operationSource), value_operationSource);
+
+            jobject value_operationError;
+            std::string value_operationErrorClassName     = "java/lang/Integer";
+            std::string value_operationErrorCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_operationErrorClassName.c_str(), value_operationErrorCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.operationError), value_operationError);
+
+            jobject value_userIndex;
+            if (cppValue.userIndex.IsNull())
+            {
+                value_userIndex = nullptr;
+            }
+            else
+            {
+                std::string value_userIndexClassName     = "java/lang/Integer";
+                std::string value_userIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(value_userIndexClassName.c_str(),
+                                                                               value_userIndexCtorSignature.c_str(),
+                                                                               cppValue.userIndex.Value(), value_userIndex);
+            }
+
+            jobject value_fabricIndex;
+            if (cppValue.fabricIndex.IsNull())
+            {
+                value_fabricIndex = nullptr;
+            }
+            else
+            {
+                std::string value_fabricIndexClassName     = "java/lang/Integer";
+                std::string value_fabricIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_fabricIndexClassName.c_str(),
+                                                                              value_fabricIndexCtorSignature.c_str(),
+                                                                              cppValue.fabricIndex.Value(), value_fabricIndex);
+            }
+
+            jobject value_sourceNode;
+            if (cppValue.sourceNode.IsNull())
+            {
+                value_sourceNode = nullptr;
+            }
+            else
+            {
+                std::string value_sourceNodeClassName     = "java/lang/Long";
+                std::string value_sourceNodeCtorSignature = "(J)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(value_sourceNodeClassName.c_str(),
+                                                                               value_sourceNodeCtorSignature.c_str(),
+                                                                               cppValue.sourceNode.Value(), value_sourceNode);
+            }
+
+            jobject value_credentials;
+            if (!cppValue.credentials.HasValue())
+            {
+                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_credentials);
+            }
+            else
+            {
+                jobject value_credentialsInsideOptional;
+                if (cppValue.credentials.Value().IsNull())
+                {
+                    value_credentialsInsideOptional = nullptr;
+                }
+                else
+                {
+                    chip::JniReferences::GetInstance().CreateArrayList(value_credentialsInsideOptional);
+
+                    auto iter_value_credentialsInsideOptional_2 = cppValue.credentials.Value().Value().begin();
+                    while (iter_value_credentialsInsideOptional_2.Next())
+                    {
+                        auto & entry_2 = iter_value_credentialsInsideOptional_2.GetValue();
+                        jobject newElement_2;
+                        jobject newElement_2_credentialType;
+                        std::string newElement_2_credentialTypeClassName     = "java/lang/Integer";
+                        std::string newElement_2_credentialTypeCtorSignature = "(I)V";
+                        chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                            newElement_2_credentialTypeClassName.c_str(), newElement_2_credentialTypeCtorSignature.c_str(),
+                            static_cast<uint8_t>(entry_2.credentialType), newElement_2_credentialType);
+                        jobject newElement_2_credentialIndex;
+                        std::string newElement_2_credentialIndexClassName     = "java/lang/Integer";
+                        std::string newElement_2_credentialIndexCtorSignature = "(I)V";
+                        chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
+                            newElement_2_credentialIndexClassName.c_str(), newElement_2_credentialIndexCtorSignature.c_str(),
+                            entry_2.credentialIndex, newElement_2_credentialIndex);
+
+                        jclass dlCredentialStructClass_3;
+                        err = chip::JniReferences::GetInstance().GetClassRef(
+                            env, "chip/devicecontroller/ChipStructs$DoorLockClusterDlCredential", dlCredentialStructClass_3);
+                        if (err != CHIP_NO_ERROR)
+                        {
+                            ChipLogError(Zcl, "Could not find class ChipStructs$DoorLockClusterDlCredential");
+                            return nullptr;
+                        }
+                        jmethodID dlCredentialStructCtor_3 =
+                            env->GetMethodID(dlCredentialStructClass_3, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+                        if (dlCredentialStructCtor_3 == nullptr)
+                        {
+                            ChipLogError(Zcl, "Could not find ChipStructs$DoorLockClusterDlCredential constructor");
+                            return nullptr;
+                        }
+
+                        newElement_2 = env->NewObject(dlCredentialStructClass_3, dlCredentialStructCtor_3,
+                                                      newElement_2_credentialType, newElement_2_credentialIndex);
+                        chip::JniReferences::GetInstance().AddToList(value_credentialsInsideOptional, newElement_2);
+                    }
+                }
+                chip::JniReferences::GetInstance().CreateOptional(value_credentialsInsideOptional, value_credentials);
+            }
+
+            jclass lockOperationErrorStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterLockOperationErrorEvent",
+                lockOperationErrorStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterLockOperationErrorEvent");
+                return nullptr;
+            }
+            jmethodID lockOperationErrorStructCtor =
+                env->GetMethodID(lockOperationErrorStructClass, "<init>",
+                                 "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/"
+                                 "Integer;Ljava/lang/Long;Ljava/util/Optional;)V");
+            if (lockOperationErrorStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$DoorLockClusterLockOperationErrorEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(lockOperationErrorStructClass, lockOperationErrorStructCtor, value_lockOperationType,
+                                           value_operationSource, value_operationError, value_userIndex, value_fabricIndex,
+                                           value_sourceNode, value_credentials);
+
+            return value;
+        }
+        case Events::LockUserChange::Id: {
+            Events::LockUserChange::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_lockDataType;
+            std::string value_lockDataTypeClassName     = "java/lang/Integer";
+            std::string value_lockDataTypeCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_lockDataTypeClassName.c_str(), value_lockDataTypeCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.lockDataType), value_lockDataType);
+
+            jobject value_dataOperationType;
+            std::string value_dataOperationTypeClassName     = "java/lang/Integer";
+            std::string value_dataOperationTypeCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_dataOperationTypeClassName.c_str(), value_dataOperationTypeCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.dataOperationType), value_dataOperationType);
+
+            jobject value_operationSource;
+            std::string value_operationSourceClassName     = "java/lang/Integer";
+            std::string value_operationSourceCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_operationSourceClassName.c_str(), value_operationSourceCtorSignature.c_str(),
+                static_cast<uint8_t>(cppValue.operationSource), value_operationSource);
+
+            jobject value_userIndex;
+            if (cppValue.userIndex.IsNull())
+            {
+                value_userIndex = nullptr;
+            }
+            else
+            {
+                std::string value_userIndexClassName     = "java/lang/Integer";
+                std::string value_userIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(value_userIndexClassName.c_str(),
+                                                                               value_userIndexCtorSignature.c_str(),
+                                                                               cppValue.userIndex.Value(), value_userIndex);
+            }
+
+            jobject value_fabricIndex;
+            if (cppValue.fabricIndex.IsNull())
+            {
+                value_fabricIndex = nullptr;
+            }
+            else
+            {
+                std::string value_fabricIndexClassName     = "java/lang/Integer";
+                std::string value_fabricIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_fabricIndexClassName.c_str(),
+                                                                              value_fabricIndexCtorSignature.c_str(),
+                                                                              cppValue.fabricIndex.Value(), value_fabricIndex);
+            }
+
+            jobject value_sourceNode;
+            if (cppValue.sourceNode.IsNull())
+            {
+                value_sourceNode = nullptr;
+            }
+            else
+            {
+                std::string value_sourceNodeClassName     = "java/lang/Long";
+                std::string value_sourceNodeCtorSignature = "(J)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(value_sourceNodeClassName.c_str(),
+                                                                               value_sourceNodeCtorSignature.c_str(),
+                                                                               cppValue.sourceNode.Value(), value_sourceNode);
+            }
+
+            jobject value_dataIndex;
+            if (cppValue.dataIndex.IsNull())
+            {
+                value_dataIndex = nullptr;
+            }
+            else
+            {
+                std::string value_dataIndexClassName     = "java/lang/Integer";
+                std::string value_dataIndexCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(value_dataIndexClassName.c_str(),
+                                                                               value_dataIndexCtorSignature.c_str(),
+                                                                               cppValue.dataIndex.Value(), value_dataIndex);
+            }
+
+            jclass lockUserChangeStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterLockUserChangeEvent", lockUserChangeStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterLockUserChangeEvent");
+                return nullptr;
+            }
+            jmethodID lockUserChangeStructCtor =
+                env->GetMethodID(lockUserChangeStructClass, "<init>",
+                                 "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/"
+                                 "Integer;Ljava/lang/Long;Ljava/lang/Integer;)V");
+            if (lockUserChangeStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$DoorLockClusterLockUserChangeEvent constructor");
+                return nullptr;
+            }
+
+            jobject value =
+                env->NewObject(lockUserChangeStructClass, lockUserChangeStructCtor, value_lockDataType, value_dataOperationType,
+                               value_operationSource, value_userIndex, value_fabricIndex, value_sourceNode, value_dataIndex);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::WindowCovering::Id: {
+        using namespace app::Clusters::WindowCovering;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::BarrierControl::Id: {
+        using namespace app::Clusters::BarrierControl;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::PumpConfigurationAndControl::Id: {
+        using namespace app::Clusters::PumpConfigurationAndControl;
+        switch (aPath.mEventId)
+        {
+        case Events::SupplyVoltageLow::Id: {
+            Events::SupplyVoltageLow::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass supplyVoltageLowStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageLowEvent",
+                supplyVoltageLowStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageLowEvent");
+                return nullptr;
+            }
+            jmethodID supplyVoltageLowStructCtor = env->GetMethodID(supplyVoltageLowStructClass, "<init>", "()V");
+            if (supplyVoltageLowStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageLowEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(supplyVoltageLowStructClass, supplyVoltageLowStructCtor);
+
+            return value;
+        }
+        case Events::SupplyVoltageHigh::Id: {
+            Events::SupplyVoltageHigh::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass supplyVoltageHighStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageHighEvent",
+                supplyVoltageHighStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageHighEvent");
+                return nullptr;
+            }
+            jmethodID supplyVoltageHighStructCtor = env->GetMethodID(supplyVoltageHighStructClass, "<init>", "()V");
+            if (supplyVoltageHighStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl, "Could not find ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageHighEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(supplyVoltageHighStructClass, supplyVoltageHighStructCtor);
+
+            return value;
+        }
+        case Events::PowerMissingPhase::Id: {
+            Events::PowerMissingPhase::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass powerMissingPhaseStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterPowerMissingPhaseEvent",
+                powerMissingPhaseStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterPowerMissingPhaseEvent");
+                return nullptr;
+            }
+            jmethodID powerMissingPhaseStructCtor = env->GetMethodID(powerMissingPhaseStructClass, "<init>", "()V");
+            if (powerMissingPhaseStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl, "Could not find ChipEventStructs$PumpConfigurationAndControlClusterPowerMissingPhaseEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(powerMissingPhaseStructClass, powerMissingPhaseStructCtor);
+
+            return value;
+        }
+        case Events::SystemPressureLow::Id: {
+            Events::SystemPressureLow::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass systemPressureLowStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureLowEvent",
+                systemPressureLowStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureLowEvent");
+                return nullptr;
+            }
+            jmethodID systemPressureLowStructCtor = env->GetMethodID(systemPressureLowStructClass, "<init>", "()V");
+            if (systemPressureLowStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl, "Could not find ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureLowEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(systemPressureLowStructClass, systemPressureLowStructCtor);
+
+            return value;
+        }
+        case Events::SystemPressureHigh::Id: {
+            Events::SystemPressureHigh::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass systemPressureHighStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureHighEvent",
+                systemPressureHighStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl,
+                             "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureHighEvent");
+                return nullptr;
+            }
+            jmethodID systemPressureHighStructCtor = env->GetMethodID(systemPressureHighStructClass, "<init>", "()V");
+            if (systemPressureHighStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl, "Could not find ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureHighEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(systemPressureHighStructClass, systemPressureHighStructCtor);
+
+            return value;
+        }
+        case Events::DryRunning::Id: {
+            Events::DryRunning::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass dryRunningStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterDryRunningEvent",
+                dryRunningStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterDryRunningEvent");
+                return nullptr;
+            }
+            jmethodID dryRunningStructCtor = env->GetMethodID(dryRunningStructClass, "<init>", "()V");
+            if (dryRunningStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$PumpConfigurationAndControlClusterDryRunningEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(dryRunningStructClass, dryRunningStructCtor);
+
+            return value;
+        }
+        case Events::MotorTemperatureHigh::Id: {
+            Events::MotorTemperatureHigh::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass motorTemperatureHighStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterMotorTemperatureHighEvent",
+                motorTemperatureHighStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl,
+                             "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterMotorTemperatureHighEvent");
+                return nullptr;
+            }
+            jmethodID motorTemperatureHighStructCtor = env->GetMethodID(motorTemperatureHighStructClass, "<init>", "()V");
+            if (motorTemperatureHighStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl, "Could not find ChipEventStructs$PumpConfigurationAndControlClusterMotorTemperatureHighEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(motorTemperatureHighStructClass, motorTemperatureHighStructCtor);
+
+            return value;
+        }
+        case Events::PumpMotorFatalFailure::Id: {
+            Events::PumpMotorFatalFailure::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass pumpMotorFatalFailureStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent",
+                pumpMotorFatalFailureStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl,
+                             "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent");
+                return nullptr;
+            }
+            jmethodID pumpMotorFatalFailureStructCtor = env->GetMethodID(pumpMotorFatalFailureStructClass, "<init>", "()V");
+            if (pumpMotorFatalFailureStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl,
+                    "Could not find ChipEventStructs$PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(pumpMotorFatalFailureStructClass, pumpMotorFatalFailureStructCtor);
+
+            return value;
+        }
+        case Events::ElectronicTemperatureHigh::Id: {
+            Events::ElectronicTemperatureHigh::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass electronicTemperatureHighStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterElectronicTemperatureHighEvent",
+                electronicTemperatureHighStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(
+                    Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterElectronicTemperatureHighEvent");
+                return nullptr;
+            }
+            jmethodID electronicTemperatureHighStructCtor = env->GetMethodID(electronicTemperatureHighStructClass, "<init>", "()V");
+            if (electronicTemperatureHighStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl,
+                    "Could not find ChipEventStructs$PumpConfigurationAndControlClusterElectronicTemperatureHighEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(electronicTemperatureHighStructClass, electronicTemperatureHighStructCtor);
+
+            return value;
+        }
+        case Events::PumpBlocked::Id: {
+            Events::PumpBlocked::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass pumpBlockedStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterPumpBlockedEvent",
+                pumpBlockedStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterPumpBlockedEvent");
+                return nullptr;
+            }
+            jmethodID pumpBlockedStructCtor = env->GetMethodID(pumpBlockedStructClass, "<init>", "()V");
+            if (pumpBlockedStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$PumpConfigurationAndControlClusterPumpBlockedEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(pumpBlockedStructClass, pumpBlockedStructCtor);
+
+            return value;
+        }
+        case Events::SensorFailure::Id: {
+            Events::SensorFailure::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass sensorFailureStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSensorFailureEvent",
+                sensorFailureStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSensorFailureEvent");
+                return nullptr;
+            }
+            jmethodID sensorFailureStructCtor = env->GetMethodID(sensorFailureStructClass, "<init>", "()V");
+            if (sensorFailureStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$PumpConfigurationAndControlClusterSensorFailureEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(sensorFailureStructClass, sensorFailureStructCtor);
+
+            return value;
+        }
+        case Events::ElectronicNonFatalFailure::Id: {
+            Events::ElectronicNonFatalFailure::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass electronicNonFatalFailureStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent",
+                electronicNonFatalFailureStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(
+                    Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent");
+                return nullptr;
+            }
+            jmethodID electronicNonFatalFailureStructCtor = env->GetMethodID(electronicNonFatalFailureStructClass, "<init>", "()V");
+            if (electronicNonFatalFailureStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl,
+                    "Could not find ChipEventStructs$PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(electronicNonFatalFailureStructClass, electronicNonFatalFailureStructCtor);
+
+            return value;
+        }
+        case Events::ElectronicFatalFailure::Id: {
+            Events::ElectronicFatalFailure::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass electronicFatalFailureStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterElectronicFatalFailureEvent",
+                electronicFatalFailureStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl,
+                             "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterElectronicFatalFailureEvent");
+                return nullptr;
+            }
+            jmethodID electronicFatalFailureStructCtor = env->GetMethodID(electronicFatalFailureStructClass, "<init>", "()V");
+            if (electronicFatalFailureStructCtor == nullptr)
+            {
+                ChipLogError(
+                    Zcl,
+                    "Could not find ChipEventStructs$PumpConfigurationAndControlClusterElectronicFatalFailureEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(electronicFatalFailureStructClass, electronicFatalFailureStructCtor);
+
+            return value;
+        }
+        case Events::GeneralFault::Id: {
+            Events::GeneralFault::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass generalFaultStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterGeneralFaultEvent",
+                generalFaultStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterGeneralFaultEvent");
+                return nullptr;
+            }
+            jmethodID generalFaultStructCtor = env->GetMethodID(generalFaultStructClass, "<init>", "()V");
+            if (generalFaultStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$PumpConfigurationAndControlClusterGeneralFaultEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(generalFaultStructClass, generalFaultStructCtor);
+
+            return value;
+        }
+        case Events::Leakage::Id: {
+            Events::Leakage::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass leakageStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterLeakageEvent", leakageStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterLeakageEvent");
+                return nullptr;
+            }
+            jmethodID leakageStructCtor = env->GetMethodID(leakageStructClass, "<init>", "()V");
+            if (leakageStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$PumpConfigurationAndControlClusterLeakageEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(leakageStructClass, leakageStructCtor);
+
+            return value;
+        }
+        case Events::AirDetection::Id: {
+            Events::AirDetection::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass airDetectionStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterAirDetectionEvent",
+                airDetectionStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterAirDetectionEvent");
+                return nullptr;
+            }
+            jmethodID airDetectionStructCtor = env->GetMethodID(airDetectionStructClass, "<init>", "()V");
+            if (airDetectionStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$PumpConfigurationAndControlClusterAirDetectionEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(airDetectionStructClass, airDetectionStructCtor);
+
+            return value;
+        }
+        case Events::TurbineOperation::Id: {
+            Events::TurbineOperation::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jclass turbineOperationStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterTurbineOperationEvent",
+                turbineOperationStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterTurbineOperationEvent");
+                return nullptr;
+            }
+            jmethodID turbineOperationStructCtor = env->GetMethodID(turbineOperationStructClass, "<init>", "()V");
+            if (turbineOperationStructCtor == nullptr)
+            {
+                ChipLogError(Zcl,
+                             "Could not find ChipEventStructs$PumpConfigurationAndControlClusterTurbineOperationEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(turbineOperationStructClass, turbineOperationStructCtor);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::Thermostat::Id: {
+        using namespace app::Clusters::Thermostat;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::FanControl::Id: {
+        using namespace app::Clusters::FanControl;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::ThermostatUserInterfaceConfiguration::Id: {
+        using namespace app::Clusters::ThermostatUserInterfaceConfiguration;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::ColorControl::Id: {
+        using namespace app::Clusters::ColorControl;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::IlluminanceMeasurement::Id: {
+        using namespace app::Clusters::IlluminanceMeasurement;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::TemperatureMeasurement::Id: {
+        using namespace app::Clusters::TemperatureMeasurement;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::PressureMeasurement::Id: {
+        using namespace app::Clusters::PressureMeasurement;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::FlowMeasurement::Id: {
+        using namespace app::Clusters::FlowMeasurement;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::RelativeHumidityMeasurement::Id: {
+        using namespace app::Clusters::RelativeHumidityMeasurement;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::OccupancySensing::Id: {
+        using namespace app::Clusters::OccupancySensing;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::WakeOnLan::Id: {
+        using namespace app::Clusters::WakeOnLan;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::Channel::Id: {
+        using namespace app::Clusters::Channel;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::TargetNavigator::Id: {
+        using namespace app::Clusters::TargetNavigator;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::MediaPlayback::Id: {
+        using namespace app::Clusters::MediaPlayback;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::MediaInput::Id: {
+        using namespace app::Clusters::MediaInput;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::LowPower::Id: {
+        using namespace app::Clusters::LowPower;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::KeypadInput::Id: {
+        using namespace app::Clusters::KeypadInput;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::ContentLauncher::Id: {
+        using namespace app::Clusters::ContentLauncher;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::AudioOutput::Id: {
+        using namespace app::Clusters::AudioOutput;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::ApplicationLauncher::Id: {
+        using namespace app::Clusters::ApplicationLauncher;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::ApplicationBasic::Id: {
+        using namespace app::Clusters::ApplicationBasic;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::AccountLogin::Id: {
+        using namespace app::Clusters::AccountLogin;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::ElectricalMeasurement::Id: {
+        using namespace app::Clusters::ElectricalMeasurement;
+        switch (aPath.mEventId)
+        {
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    case app::Clusters::TestCluster::Id: {
+        using namespace app::Clusters::TestCluster;
+        switch (aPath.mEventId)
+        {
+        case Events::TestEvent::Id: {
+            Events::TestEvent::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_arg1;
+            std::string value_arg1ClassName     = "java/lang/Integer";
+            std::string value_arg1CtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_arg1ClassName.c_str(), value_arg1CtorSignature.c_str(), cppValue.arg1, value_arg1);
+
+            jobject value_arg2;
+            std::string value_arg2ClassName     = "java/lang/Integer";
+            std::string value_arg2CtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_arg2ClassName.c_str(), value_arg2CtorSignature.c_str(), static_cast<uint8_t>(cppValue.arg2), value_arg2);
+
+            jobject value_arg3;
+            std::string value_arg3ClassName     = "java/lang/Boolean";
+            std::string value_arg3CtorSignature = "(Z)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<bool>(value_arg3ClassName.c_str(), value_arg3CtorSignature.c_str(),
+                                                                       cppValue.arg3, value_arg3);
+
+            jobject value_arg4;
+            jobject value_arg4_a;
+            std::string value_arg4_aClassName     = "java/lang/Integer";
+            std::string value_arg4_aCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_arg4_aClassName.c_str(), value_arg4_aCtorSignature.c_str(), cppValue.arg4.a, value_arg4_a);
+            jobject value_arg4_b;
+            std::string value_arg4_bClassName     = "java/lang/Boolean";
+            std::string value_arg4_bCtorSignature = "(Z)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<bool>(
+                value_arg4_bClassName.c_str(), value_arg4_bCtorSignature.c_str(), cppValue.arg4.b, value_arg4_b);
+            jobject value_arg4_c;
+            std::string value_arg4_cClassName     = "java/lang/Integer";
+            std::string value_arg4_cCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(value_arg4_cClassName.c_str(),
+                                                                          value_arg4_cCtorSignature.c_str(),
+                                                                          static_cast<uint8_t>(cppValue.arg4.c), value_arg4_c);
+            jobject value_arg4_d;
+            jbyteArray value_arg4_dByteArray = env->NewByteArray(static_cast<jsize>(cppValue.arg4.d.size()));
+            env->SetByteArrayRegion(value_arg4_dByteArray, 0, static_cast<jsize>(cppValue.arg4.d.size()),
+                                    reinterpret_cast<const jbyte *>(cppValue.arg4.d.data()));
+            value_arg4_d = value_arg4_dByteArray;
+            jobject value_arg4_e;
+            value_arg4_e = env->NewStringUTF(std::string(cppValue.arg4.e.data(), cppValue.arg4.e.size()).c_str());
+            jobject value_arg4_f;
+            std::string value_arg4_fClassName     = "java/lang/Integer";
+            std::string value_arg4_fCtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_arg4_fClassName.c_str(), value_arg4_fCtorSignature.c_str(), cppValue.arg4.f.Raw(), value_arg4_f);
+            jobject value_arg4_g;
+            std::string value_arg4_gClassName     = "java/lang/Float";
+            std::string value_arg4_gCtorSignature = "(F)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<float>(
+                value_arg4_gClassName.c_str(), value_arg4_gCtorSignature.c_str(), cppValue.arg4.g, value_arg4_g);
+            jobject value_arg4_h;
+            std::string value_arg4_hClassName     = "java/lang/Double";
+            std::string value_arg4_hCtorSignature = "(D)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<double>(
+                value_arg4_hClassName.c_str(), value_arg4_hCtorSignature.c_str(), cppValue.arg4.h, value_arg4_h);
+
+            jclass simpleStructStructClass_0;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_0);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
+                return nullptr;
+            }
+            jmethodID simpleStructStructCtor_0 =
+                env->GetMethodID(simpleStructStructClass_0, "<init>",
+                                 "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
+                                 "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
+            if (simpleStructStructCtor_0 == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
+                return nullptr;
+            }
+
+            value_arg4 = env->NewObject(simpleStructStructClass_0, simpleStructStructCtor_0, value_arg4_a, value_arg4_b,
+                                        value_arg4_c, value_arg4_d, value_arg4_e, value_arg4_f, value_arg4_g, value_arg4_h);
+
+            jobject value_arg5;
+            chip::JniReferences::GetInstance().CreateArrayList(value_arg5);
+
+            auto iter_value_arg5_0 = cppValue.arg5.begin();
+            while (iter_value_arg5_0.Next())
+            {
+                auto & entry_0 = iter_value_arg5_0.GetValue();
+                jobject newElement_0;
+                jobject newElement_0_a;
+                std::string newElement_0_aClassName     = "java/lang/Integer";
+                std::string newElement_0_aCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0_aClassName.c_str(), newElement_0_aCtorSignature.c_str(), entry_0.a, newElement_0_a);
+                jobject newElement_0_b;
+                std::string newElement_0_bClassName     = "java/lang/Boolean";
+                std::string newElement_0_bCtorSignature = "(Z)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<bool>(
+                    newElement_0_bClassName.c_str(), newElement_0_bCtorSignature.c_str(), entry_0.b, newElement_0_b);
+                jobject newElement_0_c;
+                std::string newElement_0_cClassName     = "java/lang/Integer";
+                std::string newElement_0_cCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(newElement_0_cClassName.c_str(),
+                                                                              newElement_0_cCtorSignature.c_str(),
+                                                                              static_cast<uint8_t>(entry_0.c), newElement_0_c);
+                jobject newElement_0_d;
+                jbyteArray newElement_0_dByteArray = env->NewByteArray(static_cast<jsize>(entry_0.d.size()));
+                env->SetByteArrayRegion(newElement_0_dByteArray, 0, static_cast<jsize>(entry_0.d.size()),
+                                        reinterpret_cast<const jbyte *>(entry_0.d.data()));
+                newElement_0_d = newElement_0_dByteArray;
+                jobject newElement_0_e;
+                newElement_0_e = env->NewStringUTF(std::string(entry_0.e.data(), entry_0.e.size()).c_str());
+                jobject newElement_0_f;
+                std::string newElement_0_fClassName     = "java/lang/Integer";
+                std::string newElement_0_fCtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0_fClassName.c_str(), newElement_0_fCtorSignature.c_str(), entry_0.f.Raw(), newElement_0_f);
+                jobject newElement_0_g;
+                std::string newElement_0_gClassName     = "java/lang/Float";
+                std::string newElement_0_gCtorSignature = "(F)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<float>(
+                    newElement_0_gClassName.c_str(), newElement_0_gCtorSignature.c_str(), entry_0.g, newElement_0_g);
+                jobject newElement_0_h;
+                std::string newElement_0_hClassName     = "java/lang/Double";
+                std::string newElement_0_hCtorSignature = "(D)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<double>(
+                    newElement_0_hClassName.c_str(), newElement_0_hCtorSignature.c_str(), entry_0.h, newElement_0_h);
+
+                jclass simpleStructStructClass_1;
+                err = chip::JniReferences::GetInstance().GetClassRef(
+                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_1);
+                if (err != CHIP_NO_ERROR)
+                {
+                    ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
+                    return nullptr;
+                }
+                jmethodID simpleStructStructCtor_1 =
+                    env->GetMethodID(simpleStructStructClass_1, "<init>",
+                                     "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
+                                     "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
+                if (simpleStructStructCtor_1 == nullptr)
+                {
+                    ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
+                    return nullptr;
+                }
+
+                newElement_0 =
+                    env->NewObject(simpleStructStructClass_1, simpleStructStructCtor_1, newElement_0_a, newElement_0_b,
+                                   newElement_0_c, newElement_0_d, newElement_0_e, newElement_0_f, newElement_0_g, newElement_0_h);
+                chip::JniReferences::GetInstance().AddToList(value_arg5, newElement_0);
+            }
+
+            jobject value_arg6;
+            chip::JniReferences::GetInstance().CreateArrayList(value_arg6);
+
+            auto iter_value_arg6_0 = cppValue.arg6.begin();
+            while (iter_value_arg6_0.Next())
+            {
+                auto & entry_0 = iter_value_arg6_0.GetValue();
+                jobject newElement_0;
+                std::string newElement_0ClassName     = "java/lang/Integer";
+                std::string newElement_0CtorSignature = "(I)V";
+                chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), static_cast<uint8_t>(entry_0), newElement_0);
+                chip::JniReferences::GetInstance().AddToList(value_arg6, newElement_0);
+            }
+
+            jclass testEventStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$TestClusterClusterTestEventEvent", testEventStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$TestClusterClusterTestEventEvent");
+                return nullptr;
+            }
+            jmethodID testEventStructCtor =
+                env->GetMethodID(testEventStructClass, "<init>",
+                                 "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Boolean;Lchip/devicecontroller/"
+                                 "ChipStructs$TestClusterClusterSimpleStruct;Ljava/util/ArrayList;Ljava/util/ArrayList;)V");
+            if (testEventStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$TestClusterClusterTestEventEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(testEventStructClass, testEventStructCtor, value_arg1, value_arg2, value_arg3,
+                                           value_arg4, value_arg5, value_arg6);
+
+            return value;
+        }
+        case Events::TestFabricScopedEvent::Id: {
+            Events::TestFabricScopedEvent::DecodableType cppValue;
+            *aError = app::DataModel::Decode(aReader, cppValue);
+            if (*aError != CHIP_NO_ERROR)
+            {
+                return nullptr;
+            }
+            jobject value_arg1;
+            std::string value_arg1ClassName     = "java/lang/Integer";
+            std::string value_arg1CtorSignature = "(I)V";
+            chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
+                value_arg1ClassName.c_str(), value_arg1CtorSignature.c_str(), cppValue.arg1, value_arg1);
+
+            jclass testFabricScopedEventStructClass;
+            err = chip::JniReferences::GetInstance().GetClassRef(
+                env, "chip/devicecontroller/ChipEventStructs$TestClusterClusterTestFabricScopedEventEvent",
+                testFabricScopedEventStructClass);
+            if (err != CHIP_NO_ERROR)
+            {
+                ChipLogError(Zcl, "Could not find class ChipEventStructs$TestClusterClusterTestFabricScopedEventEvent");
+                return nullptr;
+            }
+            jmethodID testFabricScopedEventStructCtor =
+                env->GetMethodID(testFabricScopedEventStructClass, "<init>", "(Ljava/lang/Integer;)V");
+            if (testFabricScopedEventStructCtor == nullptr)
+            {
+                ChipLogError(Zcl, "Could not find ChipEventStructs$TestClusterClusterTestFabricScopedEventEvent constructor");
+                return nullptr;
+            }
+
+            jobject value = env->NewObject(testFabricScopedEventStructClass, testFabricScopedEventStructCtor, value_arg1);
+
+            return value;
+        }
+        default:
+            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+            break;
+        }
+        break;
+    }
+    default:
+        *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+        break;
+    }
+    return nullptr;
+}
+
+} // namespace chip
diff --git a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp
index 90981fc2e2ac71..32ae5c41b17ca7 100644
--- a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp
+++ b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp
@@ -535,44 +535,44 @@ void CHIPScenesClusterViewSceneResponseCallback::CallbackFn(
                     chip::JniReferences::GetInstance().AddToList(newElement_3_attributeValue, newElement_5);
                 }
 
-                jclass attributeValuePairStructClass;
+                jclass attributeValuePairStructClass_4;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$ScenesClusterAttributeValuePair", attributeValuePairStructClass);
+                    env, "chip/devicecontroller/ChipStructs$ScenesClusterAttributeValuePair", attributeValuePairStructClass_4);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$ScenesClusterAttributeValuePair");
                     return;
                 }
-                jmethodID attributeValuePairStructCtor =
-                    env->GetMethodID(attributeValuePairStructClass, "<init>", "(Ljava/util/Optional;Ljava/util/ArrayList;)V");
-                if (attributeValuePairStructCtor == nullptr)
+                jmethodID attributeValuePairStructCtor_4 =
+                    env->GetMethodID(attributeValuePairStructClass_4, "<init>", "(Ljava/util/Optional;Ljava/util/ArrayList;)V");
+                if (attributeValuePairStructCtor_4 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$ScenesClusterAttributeValuePair constructor");
                     return;
                 }
 
-                newElement_3 = env->NewObject(attributeValuePairStructClass, attributeValuePairStructCtor, newElement_3_attributeId,
-                                              newElement_3_attributeValue);
+                newElement_3 = env->NewObject(attributeValuePairStructClass_4, attributeValuePairStructCtor_4,
+                                              newElement_3_attributeId, newElement_3_attributeValue);
                 chip::JniReferences::GetInstance().AddToList(newElement_1_attributeValueList, newElement_3);
             }
 
-            jclass extensionFieldSetStructClass;
+            jclass extensionFieldSetStructClass_2;
             err = chip::JniReferences::GetInstance().GetClassRef(
-                env, "chip/devicecontroller/ChipStructs$ScenesClusterExtensionFieldSet", extensionFieldSetStructClass);
+                env, "chip/devicecontroller/ChipStructs$ScenesClusterExtensionFieldSet", extensionFieldSetStructClass_2);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$ScenesClusterExtensionFieldSet");
                 return;
             }
-            jmethodID extensionFieldSetStructCtor =
-                env->GetMethodID(extensionFieldSetStructClass, "<init>", "(Ljava/lang/Long;Ljava/util/ArrayList;)V");
-            if (extensionFieldSetStructCtor == nullptr)
+            jmethodID extensionFieldSetStructCtor_2 =
+                env->GetMethodID(extensionFieldSetStructClass_2, "<init>", "(Ljava/lang/Long;Ljava/util/ArrayList;)V");
+            if (extensionFieldSetStructCtor_2 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$ScenesClusterExtensionFieldSet constructor");
                 return;
             }
 
-            newElement_1 = env->NewObject(extensionFieldSetStructClass, extensionFieldSetStructCtor, newElement_1_clusterId,
+            newElement_1 = env->NewObject(extensionFieldSetStructClass_2, extensionFieldSetStructCtor_2, newElement_1_clusterId,
                                           newElement_1_attributeValueList);
             chip::JniReferences::GetInstance().AddToList(ExtensionFieldSetsInsideOptional, newElement_1);
         }
@@ -1443,25 +1443,25 @@ void CHIPNetworkCommissioningClusterScanNetworksResponseCallback::CallbackFn(
             chip::JniReferences::GetInstance().CreateBoxedObject<int8_t>(
                 newElement_1_rssiClassName.c_str(), newElement_1_rssiCtorSignature.c_str(), entry_1.rssi, newElement_1_rssi);
 
-            jclass wiFiInterfaceScanResultStructClass;
+            jclass wiFiInterfaceScanResultStructClass_2;
             err = chip::JniReferences::GetInstance().GetClassRef(
                 env, "chip/devicecontroller/ChipStructs$NetworkCommissioningClusterWiFiInterfaceScanResult",
-                wiFiInterfaceScanResultStructClass);
+                wiFiInterfaceScanResultStructClass_2);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$NetworkCommissioningClusterWiFiInterfaceScanResult");
                 return;
             }
-            jmethodID wiFiInterfaceScanResultStructCtor =
-                env->GetMethodID(wiFiInterfaceScanResultStructClass, "<init>",
+            jmethodID wiFiInterfaceScanResultStructCtor_2 =
+                env->GetMethodID(wiFiInterfaceScanResultStructClass_2, "<init>",
                                  "(Ljava/lang/Integer;[B[BLjava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
-            if (wiFiInterfaceScanResultStructCtor == nullptr)
+            if (wiFiInterfaceScanResultStructCtor_2 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$NetworkCommissioningClusterWiFiInterfaceScanResult constructor");
                 return;
             }
 
-            newElement_1 = env->NewObject(wiFiInterfaceScanResultStructClass, wiFiInterfaceScanResultStructCtor,
+            newElement_1 = env->NewObject(wiFiInterfaceScanResultStructClass_2, wiFiInterfaceScanResultStructCtor_2,
                                           newElement_1_security, newElement_1_ssid, newElement_1_bssid, newElement_1_channel,
                                           newElement_1_wiFiBand, newElement_1_rssi);
             chip::JniReferences::GetInstance().AddToList(WiFiScanResultsInsideOptional, newElement_1);
@@ -1526,27 +1526,27 @@ void CHIPNetworkCommissioningClusterScanNetworksResponseCallback::CallbackFn(
             chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
                 newElement_1_lqiClassName.c_str(), newElement_1_lqiCtorSignature.c_str(), entry_1.lqi, newElement_1_lqi);
 
-            jclass threadInterfaceScanResultStructClass;
+            jclass threadInterfaceScanResultStructClass_2;
             err = chip::JniReferences::GetInstance().GetClassRef(
                 env, "chip/devicecontroller/ChipStructs$NetworkCommissioningClusterThreadInterfaceScanResult",
-                threadInterfaceScanResultStructClass);
+                threadInterfaceScanResultStructClass_2);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$NetworkCommissioningClusterThreadInterfaceScanResult");
                 return;
             }
-            jmethodID threadInterfaceScanResultStructCtor =
-                env->GetMethodID(threadInterfaceScanResultStructClass, "<init>",
+            jmethodID threadInterfaceScanResultStructCtor_2 =
+                env->GetMethodID(threadInterfaceScanResultStructClass_2, "<init>",
                                  "(Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/"
                                  "Integer;[BLjava/lang/Integer;Ljava/lang/Integer;)V");
-            if (threadInterfaceScanResultStructCtor == nullptr)
+            if (threadInterfaceScanResultStructCtor_2 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$NetworkCommissioningClusterThreadInterfaceScanResult constructor");
                 return;
             }
 
             newElement_1 =
-                env->NewObject(threadInterfaceScanResultStructClass, threadInterfaceScanResultStructCtor, newElement_1_panId,
+                env->NewObject(threadInterfaceScanResultStructClass_2, threadInterfaceScanResultStructCtor_2, newElement_1_panId,
                                newElement_1_extendedPanId, newElement_1_networkName, newElement_1_channel, newElement_1_version,
                                newElement_1_extendedAddress, newElement_1_rssi, newElement_1_lqi);
             chip::JniReferences::GetInstance().AddToList(ThreadScanResultsInsideOptional, newElement_1);
@@ -2241,25 +2241,25 @@ void CHIPGroupKeyManagementClusterKeySetReadResponseCallback::CallbackFn(
             dataResponse.groupKeySet.epochStartTime2.Value(), GroupKeySet_epochStartTime2);
     }
 
-    jclass groupKeySetStructStructClass;
+    jclass groupKeySetStructStructClass_0;
     err = chip::JniReferences::GetInstance().GetClassRef(
-        env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupKeySetStruct", groupKeySetStructStructClass);
+        env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupKeySetStruct", groupKeySetStructStructClass_0);
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Zcl, "Could not find class ChipStructs$GroupKeyManagementClusterGroupKeySetStruct");
         return;
     }
-    jmethodID groupKeySetStructStructCtor =
-        env->GetMethodID(groupKeySetStructStructClass, "<init>",
+    jmethodID groupKeySetStructStructCtor_0 =
+        env->GetMethodID(groupKeySetStructStructClass_0, "<init>",
                          "(Ljava/lang/Integer;Ljava/lang/Integer;[BLjava/lang/Long;[BLjava/lang/Long;[BLjava/lang/Long;)V");
-    if (groupKeySetStructStructCtor == nullptr)
+    if (groupKeySetStructStructCtor_0 == nullptr)
     {
         ChipLogError(Zcl, "Could not find ChipStructs$GroupKeyManagementClusterGroupKeySetStruct constructor");
         return;
     }
 
     GroupKeySet =
-        env->NewObject(groupKeySetStructStructClass, groupKeySetStructStructCtor, GroupKeySet_groupKeySetID,
+        env->NewObject(groupKeySetStructStructClass_0, groupKeySetStructStructCtor_0, GroupKeySet_groupKeySetID,
                        GroupKeySet_groupKeySecurityPolicy, GroupKeySet_epochKey0, GroupKeySet_epochStartTime0,
                        GroupKeySet_epochKey1, GroupKeySet_epochStartTime1, GroupKeySet_epochKey2, GroupKeySet_epochStartTime2);
 
@@ -2849,23 +2849,23 @@ void CHIPDoorLockClusterGetUserResponseCallback::CallbackFn(
                                                                            newElement_1_credentialIndexCtorSignature.c_str(),
                                                                            entry_1.credentialIndex, newElement_1_credentialIndex);
 
-            jclass dlCredentialStructClass;
+            jclass dlCredentialStructClass_2;
             err = chip::JniReferences::GetInstance().GetClassRef(
-                env, "chip/devicecontroller/ChipStructs$DoorLockClusterDlCredential", dlCredentialStructClass);
+                env, "chip/devicecontroller/ChipStructs$DoorLockClusterDlCredential", dlCredentialStructClass_2);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$DoorLockClusterDlCredential");
                 return;
             }
-            jmethodID dlCredentialStructCtor =
-                env->GetMethodID(dlCredentialStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
-            if (dlCredentialStructCtor == nullptr)
+            jmethodID dlCredentialStructCtor_2 =
+                env->GetMethodID(dlCredentialStructClass_2, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+            if (dlCredentialStructCtor_2 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$DoorLockClusterDlCredential constructor");
                 return;
             }
 
-            newElement_1 = env->NewObject(dlCredentialStructClass, dlCredentialStructCtor, newElement_1_credentialType,
+            newElement_1 = env->NewObject(dlCredentialStructClass_2, dlCredentialStructCtor_2, newElement_1_credentialType,
                                           newElement_1_credentialIndex);
             chip::JniReferences::GetInstance().AddToList(credentials, newElement_1);
         }
@@ -3226,24 +3226,24 @@ void CHIPThermostatClusterGetWeeklyScheduleResponseCallback::CallbackFn(
                                                                           entry_0.coolSetpoint.Value(), newElement_0_coolSetpoint);
         }
 
-        jclass thermostatScheduleTransitionStructClass;
+        jclass thermostatScheduleTransitionStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
             env, "chip/devicecontroller/ChipStructs$ThermostatClusterThermostatScheduleTransition",
-            thermostatScheduleTransitionStructClass);
+            thermostatScheduleTransitionStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$ThermostatClusterThermostatScheduleTransition");
             return;
         }
-        jmethodID thermostatScheduleTransitionStructCtor = env->GetMethodID(
-            thermostatScheduleTransitionStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
-        if (thermostatScheduleTransitionStructCtor == nullptr)
+        jmethodID thermostatScheduleTransitionStructCtor_1 = env->GetMethodID(
+            thermostatScheduleTransitionStructClass_1, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
+        if (thermostatScheduleTransitionStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$ThermostatClusterThermostatScheduleTransition constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(thermostatScheduleTransitionStructClass, thermostatScheduleTransitionStructCtor,
+        newElement_0 = env->NewObject(thermostatScheduleTransitionStructClass_1, thermostatScheduleTransitionStructCtor_1,
                                       newElement_0_transitionTime, newElement_0_heatSetpoint, newElement_0_coolSetpoint);
         chip::JniReferences::GetInstance().AddToList(Transitions, newElement_0);
     }
@@ -4245,25 +4245,25 @@ void CHIPTestClusterClusterSimpleStructResponseCallback::CallbackFn(
     chip::JniReferences::GetInstance().CreateBoxedObject<double>(arg1_hClassName.c_str(), arg1_hCtorSignature.c_str(),
                                                                  dataResponse.arg1.h, arg1_h);
 
-    jclass simpleStructStructClass;
+    jclass simpleStructStructClass_0;
     err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct",
-                                                         simpleStructStructClass);
+                                                         simpleStructStructClass_0);
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
         return;
     }
-    jmethodID simpleStructStructCtor = env->GetMethodID(simpleStructStructClass, "<init>",
-                                                        "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/"
-                                                        "String;Ljava/lang/Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-    if (simpleStructStructCtor == nullptr)
+    jmethodID simpleStructStructCtor_0 = env->GetMethodID(simpleStructStructClass_0, "<init>",
+                                                          "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/"
+                                                          "String;Ljava/lang/Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
+    if (simpleStructStructCtor_0 == nullptr)
     {
         ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
         return;
     }
 
-    arg1 = env->NewObject(simpleStructStructClass, simpleStructStructCtor, arg1_a, arg1_b, arg1_c, arg1_d, arg1_e, arg1_f, arg1_g,
-                          arg1_h);
+    arg1 = env->NewObject(simpleStructStructClass_0, simpleStructStructCtor_0, arg1_a, arg1_b, arg1_c, arg1_d, arg1_e, arg1_f,
+                          arg1_g, arg1_h);
 
     env->CallVoidMethod(javaCallbackRef, javaMethod, arg1);
 }
diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
index 7b0982326aa632..60630127b70501 100644
--- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
+++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
@@ -2680,23 +2680,23 @@ void CHIPDescriptorDeviceListAttributeCallback::CallbackFn(
                                                                        newElement_0_revisionCtorSignature.c_str(), entry_0.revision,
                                                                        newElement_0_revision);
 
-        jclass deviceTypeStructClass;
+        jclass deviceTypeStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$DescriptorClusterDeviceType",
-                                                             deviceTypeStructClass);
+                                                             deviceTypeStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$DescriptorClusterDeviceType");
             return;
         }
-        jmethodID deviceTypeStructCtor =
-            env->GetMethodID(deviceTypeStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;)V");
-        if (deviceTypeStructCtor == nullptr)
+        jmethodID deviceTypeStructCtor_1 =
+            env->GetMethodID(deviceTypeStructClass_1, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;)V");
+        if (deviceTypeStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$DescriptorClusterDeviceType constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(deviceTypeStructClass, deviceTypeStructCtor, newElement_0_type, newElement_0_revision);
+        newElement_0 = env->NewObject(deviceTypeStructClass_1, deviceTypeStructCtor_1, newElement_0_type, newElement_0_revision);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
 
@@ -3248,24 +3248,24 @@ void CHIPBindingBindingAttributeCallback::CallbackFn(
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass targetStructStructClass;
+        jclass targetStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$BindingClusterTargetStruct",
-                                                             targetStructStructClass);
+                                                             targetStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$BindingClusterTargetStruct");
             return;
         }
-        jmethodID targetStructStructCtor = env->GetMethodID(
-            targetStructStructClass, "<init>",
+        jmethodID targetStructStructCtor_1 = env->GetMethodID(
+            targetStructStructClass_1, "<init>",
             "(Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/lang/Integer;)V");
-        if (targetStructStructCtor == nullptr)
+        if (targetStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$BindingClusterTargetStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(targetStructStructClass, targetStructStructCtor, newElement_0_node, newElement_0_group,
+        newElement_0 = env->NewObject(targetStructStructClass_1, targetStructStructCtor_1, newElement_0_node, newElement_0_group,
                                       newElement_0_endpoint, newElement_0_cluster, newElement_0_fabricIndex);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -3632,23 +3632,23 @@ void CHIPAccessControlAclAttributeCallback::CallbackFn(
                         entry_3.deviceType.Value(), newElement_3_deviceType);
                 }
 
-                jclass targetStructClass;
+                jclass targetStructClass_4;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterTarget", targetStructClass);
+                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterTarget", targetStructClass_4);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterTarget");
                     return;
                 }
-                jmethodID targetStructCtor =
-                    env->GetMethodID(targetStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V");
-                if (targetStructCtor == nullptr)
+                jmethodID targetStructCtor_4 =
+                    env->GetMethodID(targetStructClass_4, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V");
+                if (targetStructCtor_4 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterTarget constructor");
                     return;
                 }
 
-                newElement_3 = env->NewObject(targetStructClass, targetStructCtor, newElement_3_cluster, newElement_3_endpoint,
+                newElement_3 = env->NewObject(targetStructClass_4, targetStructCtor_4, newElement_3_cluster, newElement_3_endpoint,
                                               newElement_3_deviceType);
                 chip::JniReferences::GetInstance().AddToList(newElement_0_targets, newElement_3);
             }
@@ -3660,24 +3660,24 @@ void CHIPAccessControlAclAttributeCallback::CallbackFn(
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass accessControlEntryStructClass;
+        jclass accessControlEntryStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$AccessControlClusterAccessControlEntry", accessControlEntryStructClass);
+            env, "chip/devicecontroller/ChipStructs$AccessControlClusterAccessControlEntry", accessControlEntryStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterAccessControlEntry");
             return;
         }
-        jmethodID accessControlEntryStructCtor = env->GetMethodID(
-            accessControlEntryStructClass, "<init>",
+        jmethodID accessControlEntryStructCtor_1 = env->GetMethodID(
+            accessControlEntryStructClass_1, "<init>",
             "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/ArrayList;Ljava/util/ArrayList;Ljava/lang/Integer;)V");
-        if (accessControlEntryStructCtor == nullptr)
+        if (accessControlEntryStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterAccessControlEntry constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(accessControlEntryStructClass, accessControlEntryStructCtor, newElement_0_privilege,
+        newElement_0 = env->NewObject(accessControlEntryStructClass_1, accessControlEntryStructCtor_1, newElement_0_privilege,
                                       newElement_0_authMode, newElement_0_subjects, newElement_0_targets, newElement_0_fabricIndex);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -3757,23 +3757,23 @@ void CHIPAccessControlExtensionAttributeCallback::CallbackFn(
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass extensionEntryStructClass;
+        jclass extensionEntryStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$AccessControlClusterExtensionEntry", extensionEntryStructClass);
+            env, "chip/devicecontroller/ChipStructs$AccessControlClusterExtensionEntry", extensionEntryStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterExtensionEntry");
             return;
         }
-        jmethodID extensionEntryStructCtor = env->GetMethodID(extensionEntryStructClass, "<init>", "([BLjava/lang/Integer;)V");
-        if (extensionEntryStructCtor == nullptr)
+        jmethodID extensionEntryStructCtor_1 = env->GetMethodID(extensionEntryStructClass_1, "<init>", "([BLjava/lang/Integer;)V");
+        if (extensionEntryStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterExtensionEntry constructor");
             return;
         }
 
         newElement_0 =
-            env->NewObject(extensionEntryStructClass, extensionEntryStructCtor, newElement_0_data, newElement_0_fabricIndex);
+            env->NewObject(extensionEntryStructClass_1, extensionEntryStructCtor_1, newElement_0_data, newElement_0_fabricIndex);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
 
@@ -4086,25 +4086,25 @@ void CHIPBridgedActionsActionListAttributeCallback::CallbackFn(
                                                                       newElement_0_statusCtorSignature.c_str(),
                                                                       static_cast<uint8_t>(entry_0.status), newElement_0_status);
 
-        jclass actionStructStructClass;
+        jclass actionStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$BridgedActionsClusterActionStruct", actionStructStructClass);
+            env, "chip/devicecontroller/ChipStructs$BridgedActionsClusterActionStruct", actionStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$BridgedActionsClusterActionStruct");
             return;
         }
-        jmethodID actionStructStructCtor = env->GetMethodID(
-            actionStructStructClass, "<init>",
+        jmethodID actionStructStructCtor_1 = env->GetMethodID(
+            actionStructStructClass_1, "<init>",
             "(Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
-        if (actionStructStructCtor == nullptr)
+        if (actionStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$BridgedActionsClusterActionStruct constructor");
             return;
         }
 
         newElement_0 =
-            env->NewObject(actionStructStructClass, actionStructStructCtor, newElement_0_actionID, newElement_0_name,
+            env->NewObject(actionStructStructClass_1, actionStructStructCtor_1, newElement_0_actionID, newElement_0_name,
                            newElement_0_type, newElement_0_endpointListID, newElement_0_supportedCommands, newElement_0_status);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -4204,24 +4204,24 @@ void CHIPBridgedActionsEndpointListAttributeCallback::CallbackFn(
             chip::JniReferences::GetInstance().AddToList(newElement_0_endpoints, newElement_2);
         }
 
-        jclass endpointListStructStructClass;
+        jclass endpointListStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$BridgedActionsClusterEndpointListStruct", endpointListStructStructClass);
+            env, "chip/devicecontroller/ChipStructs$BridgedActionsClusterEndpointListStruct", endpointListStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$BridgedActionsClusterEndpointListStruct");
             return;
         }
-        jmethodID endpointListStructStructCtor =
-            env->GetMethodID(endpointListStructStructClass, "<init>",
+        jmethodID endpointListStructStructCtor_1 =
+            env->GetMethodID(endpointListStructStructClass_1, "<init>",
                              "(Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/ArrayList;)V");
-        if (endpointListStructStructCtor == nullptr)
+        if (endpointListStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$BridgedActionsClusterEndpointListStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(endpointListStructStructClass, endpointListStructStructCtor, newElement_0_endpointListID,
+        newElement_0 = env->NewObject(endpointListStructStructClass_1, endpointListStructStructCtor_1, newElement_0_endpointListID,
                                       newElement_0_name, newElement_0_type, newElement_0_endpoints);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -4862,24 +4862,24 @@ void CHIPOtaSoftwareUpdateRequestorDefaultOtaProvidersAttributeCallback::Callbac
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass providerLocationStructClass;
+        jclass providerLocationStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
             env, "chip/devicecontroller/ChipStructs$OtaSoftwareUpdateRequestorClusterProviderLocation",
-            providerLocationStructClass);
+            providerLocationStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$OtaSoftwareUpdateRequestorClusterProviderLocation");
             return;
         }
-        jmethodID providerLocationStructCtor =
-            env->GetMethodID(providerLocationStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;)V");
-        if (providerLocationStructCtor == nullptr)
+        jmethodID providerLocationStructCtor_1 =
+            env->GetMethodID(providerLocationStructClass_1, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;)V");
+        if (providerLocationStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$OtaSoftwareUpdateRequestorClusterProviderLocation constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(providerLocationStructClass, providerLocationStructCtor, newElement_0_providerNodeID,
+        newElement_0 = env->NewObject(providerLocationStructClass_1, providerLocationStructCtor_1, newElement_0_providerNodeID,
                                       newElement_0_endpoint, newElement_0_fabricIndex);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -6521,23 +6521,23 @@ void CHIPNetworkCommissioningNetworksAttributeCallback::CallbackFn(
                                                                    newElement_0_connectedCtorSignature.c_str(), entry_0.connected,
                                                                    newElement_0_connected);
 
-        jclass networkInfoStructClass;
+        jclass networkInfoStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$NetworkCommissioningClusterNetworkInfo", networkInfoStructClass);
+            env, "chip/devicecontroller/ChipStructs$NetworkCommissioningClusterNetworkInfo", networkInfoStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$NetworkCommissioningClusterNetworkInfo");
             return;
         }
-        jmethodID networkInfoStructCtor = env->GetMethodID(networkInfoStructClass, "<init>", "([BLjava/lang/Boolean;)V");
-        if (networkInfoStructCtor == nullptr)
+        jmethodID networkInfoStructCtor_1 = env->GetMethodID(networkInfoStructClass_1, "<init>", "([BLjava/lang/Boolean;)V");
+        if (networkInfoStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$NetworkCommissioningClusterNetworkInfo constructor");
             return;
         }
 
         newElement_0 =
-            env->NewObject(networkInfoStructClass, networkInfoStructCtor, newElement_0_networkID, newElement_0_connected);
+            env->NewObject(networkInfoStructClass_1, networkInfoStructCtor_1, newElement_0_networkID, newElement_0_connected);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
 
@@ -7240,26 +7240,26 @@ void CHIPGeneralDiagnosticsNetworkInterfacesAttributeCallback::CallbackFn(
                                                                       newElement_0_typeCtorSignature.c_str(),
                                                                       static_cast<uint8_t>(entry_0.type), newElement_0_type);
 
-        jclass networkInterfaceTypeStructClass;
+        jclass networkInterfaceTypeStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
             env, "chip/devicecontroller/ChipStructs$GeneralDiagnosticsClusterNetworkInterfaceType",
-            networkInterfaceTypeStructClass);
+            networkInterfaceTypeStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$GeneralDiagnosticsClusterNetworkInterfaceType");
             return;
         }
-        jmethodID networkInterfaceTypeStructCtor =
-            env->GetMethodID(networkInterfaceTypeStructClass, "<init>",
+        jmethodID networkInterfaceTypeStructCtor_1 =
+            env->GetMethodID(networkInterfaceTypeStructClass_1, "<init>",
                              "(Ljava/lang/String;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;[BLjava/util/"
                              "ArrayList;Ljava/util/ArrayList;Ljava/lang/Integer;)V");
-        if (networkInterfaceTypeStructCtor == nullptr)
+        if (networkInterfaceTypeStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$GeneralDiagnosticsClusterNetworkInterfaceType constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(networkInterfaceTypeStructClass, networkInterfaceTypeStructCtor, newElement_0_name,
+        newElement_0 = env->NewObject(networkInterfaceTypeStructClass_1, networkInterfaceTypeStructCtor_1, newElement_0_name,
                                       newElement_0_isOperational, newElement_0_offPremiseServicesReachableIPv4,
                                       newElement_0_offPremiseServicesReachableIPv6, newElement_0_hardwareAddress,
                                       newElement_0_IPv4Addresses, newElement_0_IPv6Addresses, newElement_0_type);
@@ -7825,24 +7825,24 @@ void CHIPSoftwareDiagnosticsThreadMetricsAttributeCallback::CallbackFn(
             chip::JniReferences::GetInstance().CreateOptional(newElement_0_stackSizeInsideOptional, newElement_0_stackSize);
         }
 
-        jclass threadMetricsStructClass;
+        jclass threadMetricsStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$SoftwareDiagnosticsClusterThreadMetrics", threadMetricsStructClass);
+            env, "chip/devicecontroller/ChipStructs$SoftwareDiagnosticsClusterThreadMetrics", threadMetricsStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$SoftwareDiagnosticsClusterThreadMetrics");
             return;
         }
-        jmethodID threadMetricsStructCtor =
-            env->GetMethodID(threadMetricsStructClass, "<init>",
+        jmethodID threadMetricsStructCtor_1 =
+            env->GetMethodID(threadMetricsStructClass_1, "<init>",
                              "(Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V");
-        if (threadMetricsStructCtor == nullptr)
+        if (threadMetricsStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$SoftwareDiagnosticsClusterThreadMetrics constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(threadMetricsStructClass, threadMetricsStructCtor, newElement_0_id, newElement_0_name,
+        newElement_0 = env->NewObject(threadMetricsStructClass_1, threadMetricsStructCtor_1, newElement_0_id, newElement_0_name,
                                       newElement_0_stackFreeCurrent, newElement_0_stackFreeMinimum, newElement_0_stackSize);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -8621,30 +8621,30 @@ void CHIPThreadNetworkDiagnosticsNeighborTableListAttributeCallback::CallbackFn(
                                                                    newElement_0_isChildCtorSignature.c_str(), entry_0.isChild,
                                                                    newElement_0_isChild);
 
-        jclass neighborTableStructClass;
+        jclass neighborTableStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterNeighborTable", neighborTableStructClass);
+            env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterNeighborTable", neighborTableStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$ThreadNetworkDiagnosticsClusterNeighborTable");
             return;
         }
-        jmethodID neighborTableStructCtor =
-            env->GetMethodID(neighborTableStructClass, "<init>",
+        jmethodID neighborTableStructCtor_1 =
+            env->GetMethodID(neighborTableStructClass_1, "<init>",
                              "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/"
                              "Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/"
                              "Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;)V");
-        if (neighborTableStructCtor == nullptr)
+        if (neighborTableStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$ThreadNetworkDiagnosticsClusterNeighborTable constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(neighborTableStructClass, neighborTableStructCtor, newElement_0_extAddress, newElement_0_age,
-                                      newElement_0_rloc16, newElement_0_linkFrameCounter, newElement_0_mleFrameCounter,
-                                      newElement_0_lqi, newElement_0_averageRssi, newElement_0_lastRssi,
-                                      newElement_0_frameErrorRate, newElement_0_messageErrorRate, newElement_0_rxOnWhenIdle,
-                                      newElement_0_fullThreadDevice, newElement_0_fullNetworkData, newElement_0_isChild);
+        newElement_0 = env->NewObject(
+            neighborTableStructClass_1, neighborTableStructCtor_1, newElement_0_extAddress, newElement_0_age, newElement_0_rloc16,
+            newElement_0_linkFrameCounter, newElement_0_mleFrameCounter, newElement_0_lqi, newElement_0_averageRssi,
+            newElement_0_lastRssi, newElement_0_frameErrorRate, newElement_0_messageErrorRate, newElement_0_rxOnWhenIdle,
+            newElement_0_fullThreadDevice, newElement_0_fullNetworkData, newElement_0_isChild);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
 
@@ -8771,25 +8771,25 @@ void CHIPThreadNetworkDiagnosticsRouteTableListAttributeCallback::CallbackFn(
                                                                    newElement_0_linkEstablishedCtorSignature.c_str(),
                                                                    entry_0.linkEstablished, newElement_0_linkEstablished);
 
-        jclass routeTableStructClass;
+        jclass routeTableStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterRouteTable", routeTableStructClass);
+            env, "chip/devicecontroller/ChipStructs$ThreadNetworkDiagnosticsClusterRouteTable", routeTableStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$ThreadNetworkDiagnosticsClusterRouteTable");
             return;
         }
-        jmethodID routeTableStructCtor =
-            env->GetMethodID(routeTableStructClass, "<init>",
+        jmethodID routeTableStructCtor_1 =
+            env->GetMethodID(routeTableStructClass_1, "<init>",
                              "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/"
                              "lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Boolean;)V");
-        if (routeTableStructCtor == nullptr)
+        if (routeTableStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$ThreadNetworkDiagnosticsClusterRouteTable constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(routeTableStructClass, routeTableStructCtor, newElement_0_extAddress, newElement_0_rloc16,
+        newElement_0 = env->NewObject(routeTableStructClass_1, routeTableStructCtor_1, newElement_0_extAddress, newElement_0_rloc16,
                                       newElement_0_routerId, newElement_0_nextHop, newElement_0_pathCost, newElement_0_LQIIn,
                                       newElement_0_LQIOut, newElement_0_age, newElement_0_allocated, newElement_0_linkEstablished);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
@@ -11496,22 +11496,22 @@ void CHIPOperationalCredentialsNOCsAttributeCallback::CallbackFn(
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass NOCStructStructClass;
+        jclass NOCStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$OperationalCredentialsClusterNOCStruct", NOCStructStructClass);
+            env, "chip/devicecontroller/ChipStructs$OperationalCredentialsClusterNOCStruct", NOCStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$OperationalCredentialsClusterNOCStruct");
             return;
         }
-        jmethodID NOCStructStructCtor = env->GetMethodID(NOCStructStructClass, "<init>", "([B[BLjava/lang/Integer;)V");
-        if (NOCStructStructCtor == nullptr)
+        jmethodID NOCStructStructCtor_1 = env->GetMethodID(NOCStructStructClass_1, "<init>", "([B[BLjava/lang/Integer;)V");
+        if (NOCStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$OperationalCredentialsClusterNOCStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(NOCStructStructClass, NOCStructStructCtor, newElement_0_noc, newElement_0_icac,
+        newElement_0 = env->NewObject(NOCStructStructClass_1, NOCStructStructCtor_1, newElement_0_noc, newElement_0_icac,
                                       newElement_0_fabricIndex);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -11613,24 +11613,24 @@ void CHIPOperationalCredentialsFabricsAttributeCallback::CallbackFn(
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass fabricDescriptorStructClass;
+        jclass fabricDescriptorStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$OperationalCredentialsClusterFabricDescriptor", fabricDescriptorStructClass);
+            env, "chip/devicecontroller/ChipStructs$OperationalCredentialsClusterFabricDescriptor", fabricDescriptorStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$OperationalCredentialsClusterFabricDescriptor");
             return;
         }
-        jmethodID fabricDescriptorStructCtor =
-            env->GetMethodID(fabricDescriptorStructClass, "<init>",
+        jmethodID fabricDescriptorStructCtor_1 =
+            env->GetMethodID(fabricDescriptorStructClass_1, "<init>",
                              "([BLjava/lang/Integer;Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/String;Ljava/lang/Integer;)V");
-        if (fabricDescriptorStructCtor == nullptr)
+        if (fabricDescriptorStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$OperationalCredentialsClusterFabricDescriptor constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(fabricDescriptorStructClass, fabricDescriptorStructCtor, newElement_0_rootPublicKey,
+        newElement_0 = env->NewObject(fabricDescriptorStructClass_1, fabricDescriptorStructCtor_1, newElement_0_rootPublicKey,
                                       newElement_0_vendorId, newElement_0_fabricId, newElement_0_nodeId, newElement_0_label,
                                       newElement_0_fabricIndex);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
@@ -12065,23 +12065,23 @@ void CHIPGroupKeyManagementGroupKeyMapAttributeCallback::CallbackFn(
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass groupKeyMapStructStructClass;
+        jclass groupKeyMapStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupKeyMapStruct", groupKeyMapStructStructClass);
+            env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupKeyMapStruct", groupKeyMapStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$GroupKeyManagementClusterGroupKeyMapStruct");
             return;
         }
-        jmethodID groupKeyMapStructStructCtor = env->GetMethodID(groupKeyMapStructStructClass, "<init>",
-                                                                 "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
-        if (groupKeyMapStructStructCtor == nullptr)
+        jmethodID groupKeyMapStructStructCtor_1 = env->GetMethodID(groupKeyMapStructStructClass_1, "<init>",
+                                                                   "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
+        if (groupKeyMapStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$GroupKeyManagementClusterGroupKeyMapStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(groupKeyMapStructStructClass, groupKeyMapStructStructCtor, newElement_0_groupId,
+        newElement_0 = env->NewObject(groupKeyMapStructStructClass_1, groupKeyMapStructStructCtor_1, newElement_0_groupId,
                                       newElement_0_groupKeySetID, newElement_0_fabricIndex);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -12191,24 +12191,24 @@ void CHIPGroupKeyManagementGroupTableAttributeCallback::CallbackFn(
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass groupInfoMapStructStructClass;
+        jclass groupInfoMapStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupInfoMapStruct", groupInfoMapStructStructClass);
+            env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupInfoMapStruct", groupInfoMapStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$GroupKeyManagementClusterGroupInfoMapStruct");
             return;
         }
-        jmethodID groupInfoMapStructStructCtor =
-            env->GetMethodID(groupInfoMapStructStructClass, "<init>",
+        jmethodID groupInfoMapStructStructCtor_1 =
+            env->GetMethodID(groupInfoMapStructStructClass_1, "<init>",
                              "(Ljava/lang/Integer;Ljava/util/ArrayList;Ljava/util/Optional;Ljava/lang/Integer;)V");
-        if (groupInfoMapStructStructCtor == nullptr)
+        if (groupInfoMapStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$GroupKeyManagementClusterGroupInfoMapStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(groupInfoMapStructStructClass, groupInfoMapStructStructCtor, newElement_0_groupId,
+        newElement_0 = env->NewObject(groupInfoMapStructStructClass_1, groupInfoMapStructStructCtor_1, newElement_0_groupId,
                                       newElement_0_endpoints, newElement_0_groupName, newElement_0_fabricIndex);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -12494,23 +12494,23 @@ void CHIPFixedLabelLabelListAttributeCallback::CallbackFn(
         jobject newElement_0_value;
         newElement_0_value = env->NewStringUTF(std::string(entry_0.value.data(), entry_0.value.size()).c_str());
 
-        jclass labelStructStructClass;
+        jclass labelStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$FixedLabelClusterLabelStruct",
-                                                             labelStructStructClass);
+                                                             labelStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$FixedLabelClusterLabelStruct");
             return;
         }
-        jmethodID labelStructStructCtor =
-            env->GetMethodID(labelStructStructClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
-        if (labelStructStructCtor == nullptr)
+        jmethodID labelStructStructCtor_1 =
+            env->GetMethodID(labelStructStructClass_1, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
+        if (labelStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$FixedLabelClusterLabelStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(labelStructStructClass, labelStructStructCtor, newElement_0_label, newElement_0_value);
+        newElement_0 = env->NewObject(labelStructStructClass_1, labelStructStructCtor_1, newElement_0_label, newElement_0_value);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
 
@@ -12793,23 +12793,23 @@ void CHIPUserLabelLabelListAttributeCallback::CallbackFn(
         jobject newElement_0_value;
         newElement_0_value = env->NewStringUTF(std::string(entry_0.value.data(), entry_0.value.size()).c_str());
 
-        jclass labelStructStructClass;
+        jclass labelStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$UserLabelClusterLabelStruct",
-                                                             labelStructStructClass);
+                                                             labelStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$UserLabelClusterLabelStruct");
             return;
         }
-        jmethodID labelStructStructCtor =
-            env->GetMethodID(labelStructStructClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
-        if (labelStructStructCtor == nullptr)
+        jmethodID labelStructStructCtor_1 =
+            env->GetMethodID(labelStructStructClass_1, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
+        if (labelStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$UserLabelClusterLabelStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(labelStructStructClass, labelStructStructCtor, newElement_0_label, newElement_0_value);
+        newElement_0 = env->NewObject(labelStructStructClass_1, labelStructStructCtor_1, newElement_0_label, newElement_0_value);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
 
@@ -13325,43 +13325,44 @@ void CHIPModeSelectSupportedModesAttributeCallback::CallbackFn(
             chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
                 newElement_2_valueClassName.c_str(), newElement_2_valueCtorSignature.c_str(), entry_2.value, newElement_2_value);
 
-            jclass semanticTagStructClass;
+            jclass semanticTagStructClass_3;
             err = chip::JniReferences::GetInstance().GetClassRef(
-                env, "chip/devicecontroller/ChipStructs$ModeSelectClusterSemanticTag", semanticTagStructClass);
+                env, "chip/devicecontroller/ChipStructs$ModeSelectClusterSemanticTag", semanticTagStructClass_3);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$ModeSelectClusterSemanticTag");
                 return;
             }
-            jmethodID semanticTagStructCtor =
-                env->GetMethodID(semanticTagStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
-            if (semanticTagStructCtor == nullptr)
+            jmethodID semanticTagStructCtor_3 =
+                env->GetMethodID(semanticTagStructClass_3, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
+            if (semanticTagStructCtor_3 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$ModeSelectClusterSemanticTag constructor");
                 return;
             }
 
-            newElement_2 = env->NewObject(semanticTagStructClass, semanticTagStructCtor, newElement_2_mfgCode, newElement_2_value);
+            newElement_2 =
+                env->NewObject(semanticTagStructClass_3, semanticTagStructCtor_3, newElement_2_mfgCode, newElement_2_value);
             chip::JniReferences::GetInstance().AddToList(newElement_0_semanticTags, newElement_2);
         }
 
-        jclass modeOptionStructStructClass;
+        jclass modeOptionStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$ModeSelectClusterModeOptionStruct", modeOptionStructStructClass);
+            env, "chip/devicecontroller/ChipStructs$ModeSelectClusterModeOptionStruct", modeOptionStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$ModeSelectClusterModeOptionStruct");
             return;
         }
-        jmethodID modeOptionStructStructCtor = env->GetMethodID(modeOptionStructStructClass, "<init>",
-                                                                "(Ljava/lang/String;Ljava/lang/Integer;Ljava/util/ArrayList;)V");
-        if (modeOptionStructStructCtor == nullptr)
+        jmethodID modeOptionStructStructCtor_1 = env->GetMethodID(modeOptionStructStructClass_1, "<init>",
+                                                                  "(Ljava/lang/String;Ljava/lang/Integer;Ljava/util/ArrayList;)V");
+        if (modeOptionStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$ModeSelectClusterModeOptionStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(modeOptionStructStructClass, modeOptionStructStructCtor, newElement_0_label,
+        newElement_0 = env->NewObject(modeOptionStructStructClass_1, modeOptionStructStructCtor_1, newElement_0_label,
                                       newElement_0_mode, newElement_0_semanticTags);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -20613,25 +20614,25 @@ void CHIPChannelChannelListAttributeCallback::CallbackFn(
                                                               newElement_0_affiliateCallSign);
         }
 
-        jclass channelInfoStructClass;
+        jclass channelInfoStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$ChannelClusterChannelInfo",
-                                                             channelInfoStructClass);
+                                                             channelInfoStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$ChannelClusterChannelInfo");
             return;
         }
-        jmethodID channelInfoStructCtor = env->GetMethodID(
-            channelInfoStructClass, "<init>",
+        jmethodID channelInfoStructCtor_1 = env->GetMethodID(
+            channelInfoStructClass_1, "<init>",
             "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V");
-        if (channelInfoStructCtor == nullptr)
+        if (channelInfoStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$ChannelClusterChannelInfo constructor");
             return;
         }
 
         newElement_0 =
-            env->NewObject(channelInfoStructClass, channelInfoStructCtor, newElement_0_majorNumber, newElement_0_minorNumber,
+            env->NewObject(channelInfoStructClass_1, channelInfoStructCtor_1, newElement_0_majorNumber, newElement_0_minorNumber,
                            newElement_0_name, newElement_0_callSign, newElement_0_affiliateCallSign);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -20921,23 +20922,23 @@ void CHIPTargetNavigatorTargetListAttributeCallback::CallbackFn(
         jobject newElement_0_name;
         newElement_0_name = env->NewStringUTF(std::string(entry_0.name.data(), entry_0.name.size()).c_str());
 
-        jclass targetInfoStructClass;
+        jclass targetInfoStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$TargetNavigatorClusterTargetInfo", targetInfoStructClass);
+            env, "chip/devicecontroller/ChipStructs$TargetNavigatorClusterTargetInfo", targetInfoStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$TargetNavigatorClusterTargetInfo");
             return;
         }
-        jmethodID targetInfoStructCtor =
-            env->GetMethodID(targetInfoStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
-        if (targetInfoStructCtor == nullptr)
+        jmethodID targetInfoStructCtor_1 =
+            env->GetMethodID(targetInfoStructClass_1, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
+        if (targetInfoStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$TargetNavigatorClusterTargetInfo constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(targetInfoStructClass, targetInfoStructCtor, newElement_0_identifier, newElement_0_name);
+        newElement_0 = env->NewObject(targetInfoStructClass_1, targetInfoStructCtor_1, newElement_0_identifier, newElement_0_name);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
 
@@ -21708,23 +21709,23 @@ void CHIPMediaInputInputListAttributeCallback::CallbackFn(
         jobject newElement_0_description;
         newElement_0_description = env->NewStringUTF(std::string(entry_0.description.data(), entry_0.description.size()).c_str());
 
-        jclass inputInfoStructClass;
+        jclass inputInfoStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$MediaInputClusterInputInfo",
-                                                             inputInfoStructClass);
+                                                             inputInfoStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$MediaInputClusterInputInfo");
             return;
         }
-        jmethodID inputInfoStructCtor = env->GetMethodID(
-            inputInfoStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;)V");
-        if (inputInfoStructCtor == nullptr)
+        jmethodID inputInfoStructCtor_1 = env->GetMethodID(
+            inputInfoStructClass_1, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;)V");
+        if (inputInfoStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$MediaInputClusterInputInfo constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(inputInfoStructClass, inputInfoStructCtor, newElement_0_index, newElement_0_inputType,
+        newElement_0 = env->NewObject(inputInfoStructClass_1, inputInfoStructCtor_1, newElement_0_index, newElement_0_inputType,
                                       newElement_0_name, newElement_0_description);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -22720,23 +22721,23 @@ void CHIPAudioOutputOutputListAttributeCallback::CallbackFn(
         jobject newElement_0_name;
         newElement_0_name = env->NewStringUTF(std::string(entry_0.name.data(), entry_0.name.size()).c_str());
 
-        jclass outputInfoStructClass;
+        jclass outputInfoStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$AudioOutputClusterOutputInfo",
-                                                             outputInfoStructClass);
+                                                             outputInfoStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$AudioOutputClusterOutputInfo");
             return;
         }
-        jmethodID outputInfoStructCtor =
-            env->GetMethodID(outputInfoStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;)V");
-        if (outputInfoStructCtor == nullptr)
+        jmethodID outputInfoStructCtor_1 =
+            env->GetMethodID(outputInfoStructClass_1, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;)V");
+        if (outputInfoStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$AudioOutputClusterOutputInfo constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(outputInfoStructClass, outputInfoStructCtor, newElement_0_index, newElement_0_outputType,
+        newElement_0 = env->NewObject(outputInfoStructClass_1, outputInfoStructCtor_1, newElement_0_index, newElement_0_outputType,
                                       newElement_0_name);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -24163,23 +24164,23 @@ void CHIPTestClusterListStructOctetStringAttributeCallback::CallbackFn(
                                 reinterpret_cast<const jbyte *>(entry_0.member2.data()));
         newElement_0_member2 = newElement_0_member2ByteArray;
 
-        jclass testListStructOctetStructClass;
+        jclass testListStructOctetStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$TestClusterClusterTestListStructOctet", testListStructOctetStructClass);
+            env, "chip/devicecontroller/ChipStructs$TestClusterClusterTestListStructOctet", testListStructOctetStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterTestListStructOctet");
             return;
         }
-        jmethodID testListStructOctetStructCtor =
-            env->GetMethodID(testListStructOctetStructClass, "<init>", "(Ljava/lang/Long;[B)V");
-        if (testListStructOctetStructCtor == nullptr)
+        jmethodID testListStructOctetStructCtor_1 =
+            env->GetMethodID(testListStructOctetStructClass_1, "<init>", "(Ljava/lang/Long;[B)V");
+        if (testListStructOctetStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterTestListStructOctet constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(testListStructOctetStructClass, testListStructOctetStructCtor, newElement_0_member1,
+        newElement_0 = env->NewObject(testListStructOctetStructClass_1, testListStructOctetStructCtor_1, newElement_0_member1,
                                       newElement_0_member2);
         chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
     }
@@ -24459,26 +24460,26 @@ void CHIPTestClusterListNullablesAndOptionalsStructAttributeCallback::CallbackFn
                 newElement_0_nullableStruct_hClassName.c_str(), newElement_0_nullableStruct_hCtorSignature.c_str(),
                 entry_0.nullableStruct.Value().h, newElement_0_nullableStruct_h);
 
-            jclass simpleStructStructClass;
+            jclass simpleStructStructClass_3;
             err = chip::JniReferences::GetInstance().GetClassRef(
-                env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_3);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                 return;
             }
-            jmethodID simpleStructStructCtor =
-                env->GetMethodID(simpleStructStructClass, "<init>",
+            jmethodID simpleStructStructCtor_3 =
+                env->GetMethodID(simpleStructStructClass_3, "<init>",
                                  "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
                                  "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-            if (simpleStructStructCtor == nullptr)
+            if (simpleStructStructCtor_3 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                 return;
             }
 
             newElement_0_nullableStruct = env->NewObject(
-                simpleStructStructClass, simpleStructStructCtor, newElement_0_nullableStruct_a, newElement_0_nullableStruct_b,
+                simpleStructStructClass_3, simpleStructStructCtor_3, newElement_0_nullableStruct_a, newElement_0_nullableStruct_b,
                 newElement_0_nullableStruct_c, newElement_0_nullableStruct_d, newElement_0_nullableStruct_e,
                 newElement_0_nullableStruct_f, newElement_0_nullableStruct_g, newElement_0_nullableStruct_h);
         }
@@ -24543,26 +24544,26 @@ void CHIPTestClusterListNullablesAndOptionalsStructAttributeCallback::CallbackFn
                 newElement_0_optionalStructInsideOptional_hCtorSignature.c_str(), entry_0.optionalStruct.Value().h,
                 newElement_0_optionalStructInsideOptional_h);
 
-            jclass simpleStructStructClass;
+            jclass simpleStructStructClass_3;
             err = chip::JniReferences::GetInstance().GetClassRef(
-                env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_3);
             if (err != CHIP_NO_ERROR)
             {
                 ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                 return;
             }
-            jmethodID simpleStructStructCtor =
-                env->GetMethodID(simpleStructStructClass, "<init>",
+            jmethodID simpleStructStructCtor_3 =
+                env->GetMethodID(simpleStructStructClass_3, "<init>",
                                  "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
                                  "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-            if (simpleStructStructCtor == nullptr)
+            if (simpleStructStructCtor_3 == nullptr)
             {
                 ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                 return;
             }
 
             newElement_0_optionalStructInsideOptional =
-                env->NewObject(simpleStructStructClass, simpleStructStructCtor, newElement_0_optionalStructInsideOptional_a,
+                env->NewObject(simpleStructStructClass_3, simpleStructStructCtor_3, newElement_0_optionalStructInsideOptional_a,
                                newElement_0_optionalStructInsideOptional_b, newElement_0_optionalStructInsideOptional_c,
                                newElement_0_optionalStructInsideOptional_d, newElement_0_optionalStructInsideOptional_e,
                                newElement_0_optionalStructInsideOptional_f, newElement_0_optionalStructInsideOptional_g,
@@ -24640,26 +24641,26 @@ void CHIPTestClusterListNullablesAndOptionalsStructAttributeCallback::CallbackFn
                     newElement_0_nullableOptionalStructInsideOptional_hCtorSignature.c_str(),
                     entry_0.nullableOptionalStruct.Value().Value().h, newElement_0_nullableOptionalStructInsideOptional_h);
 
-                jclass simpleStructStructClass;
+                jclass simpleStructStructClass_4;
                 err = chip::JniReferences::GetInstance().GetClassRef(
-                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+                    env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_4);
                 if (err != CHIP_NO_ERROR)
                 {
                     ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
                     return;
                 }
-                jmethodID simpleStructStructCtor =
-                    env->GetMethodID(simpleStructStructClass, "<init>",
+                jmethodID simpleStructStructCtor_4 =
+                    env->GetMethodID(simpleStructStructClass_4, "<init>",
                                      "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
                                      "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-                if (simpleStructStructCtor == nullptr)
+                if (simpleStructStructCtor_4 == nullptr)
                 {
                     ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
                     return;
                 }
 
                 newElement_0_nullableOptionalStructInsideOptional = env->NewObject(
-                    simpleStructStructClass, simpleStructStructCtor, newElement_0_nullableOptionalStructInsideOptional_a,
+                    simpleStructStructClass_4, simpleStructStructCtor_4, newElement_0_nullableOptionalStructInsideOptional_a,
                     newElement_0_nullableOptionalStructInsideOptional_b, newElement_0_nullableOptionalStructInsideOptional_c,
                     newElement_0_nullableOptionalStructInsideOptional_d, newElement_0_nullableOptionalStructInsideOptional_e,
                     newElement_0_nullableOptionalStructInsideOptional_f, newElement_0_nullableOptionalStructInsideOptional_g,
@@ -24745,27 +24746,27 @@ void CHIPTestClusterListNullablesAndOptionalsStructAttributeCallback::CallbackFn
                                                               newElement_0_nullableOptionalList);
         }
 
-        jclass nullablesAndOptionalsStructStructClass;
+        jclass nullablesAndOptionalsStructStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
             env, "chip/devicecontroller/ChipStructs$TestClusterClusterNullablesAndOptionalsStruct",
-            nullablesAndOptionalsStructStructClass);
+            nullablesAndOptionalsStructStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterNullablesAndOptionalsStruct");
             return;
         }
-        jmethodID nullablesAndOptionalsStructStructCtor =
-            env->GetMethodID(nullablesAndOptionalsStructStructClass, "<init>",
+        jmethodID nullablesAndOptionalsStructStructCtor_1 =
+            env->GetMethodID(nullablesAndOptionalsStructStructClass_1, "<init>",
                              "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;Ljava/lang/String;Ljava/util/"
                              "Optional;Ljava/util/Optional;Lchip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct;Ljava/"
                              "util/Optional;Ljava/util/Optional;Ljava/util/ArrayList;Ljava/util/Optional;Ljava/util/Optional;)V");
-        if (nullablesAndOptionalsStructStructCtor == nullptr)
+        if (nullablesAndOptionalsStructStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterNullablesAndOptionalsStruct constructor");
             return;
         }
 
-        newElement_0 = env->NewObject(nullablesAndOptionalsStructStructClass, nullablesAndOptionalsStructStructCtor,
+        newElement_0 = env->NewObject(nullablesAndOptionalsStructStructClass_1, nullablesAndOptionalsStructStructCtor_1,
                                       newElement_0_nullableInt, newElement_0_optionalInt, newElement_0_nullableOptionalInt,
                                       newElement_0_nullableString, newElement_0_optionalString, newElement_0_nullableOptionalString,
                                       newElement_0_nullableStruct, newElement_0_optionalStruct, newElement_0_nullableOptionalStruct,
@@ -25022,25 +25023,26 @@ void CHIPTestClusterListFabricScopedAttributeCallback::CallbackFn(
             newElement_0_fabricSensitiveStruct_hClassName.c_str(), newElement_0_fabricSensitiveStruct_hCtorSignature.c_str(),
             entry_0.fabricSensitiveStruct.h, newElement_0_fabricSensitiveStruct_h);
 
-        jclass simpleStructStructClass;
+        jclass simpleStructStructClass_2;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass);
+            env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct", simpleStructStructClass_2);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct");
             return;
         }
-        jmethodID simpleStructStructCtor = env->GetMethodID(simpleStructStructClass, "<init>",
-                                                            "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/"
-                                                            "lang/String;Ljava/lang/Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
-        if (simpleStructStructCtor == nullptr)
+        jmethodID simpleStructStructCtor_2 =
+            env->GetMethodID(simpleStructStructClass_2, "<init>",
+                             "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/String;Ljava/lang/"
+                             "Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
+        if (simpleStructStructCtor_2 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor");
             return;
         }
 
         newElement_0_fabricSensitiveStruct = env->NewObject(
-            simpleStructStructClass, simpleStructStructCtor, newElement_0_fabricSensitiveStruct_a,
+            simpleStructStructClass_2, simpleStructStructCtor_2, newElement_0_fabricSensitiveStruct_a,
             newElement_0_fabricSensitiveStruct_b, newElement_0_fabricSensitiveStruct_c, newElement_0_fabricSensitiveStruct_d,
             newElement_0_fabricSensitiveStruct_e, newElement_0_fabricSensitiveStruct_f, newElement_0_fabricSensitiveStruct_g,
             newElement_0_fabricSensitiveStruct_h);
@@ -25065,26 +25067,26 @@ void CHIPTestClusterListFabricScopedAttributeCallback::CallbackFn(
                                                                       newElement_0_fabricIndexCtorSignature.c_str(),
                                                                       entry_0.fabricIndex, newElement_0_fabricIndex);
 
-        jclass testFabricScopedStructClass;
+        jclass testFabricScopedStructClass_1;
         err = chip::JniReferences::GetInstance().GetClassRef(
-            env, "chip/devicecontroller/ChipStructs$TestClusterClusterTestFabricScoped", testFabricScopedStructClass);
+            env, "chip/devicecontroller/ChipStructs$TestClusterClusterTestFabricScoped", testFabricScopedStructClass_1);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterTestFabricScoped");
             return;
         }
-        jmethodID testFabricScopedStructCtor = env->GetMethodID(
-            testFabricScopedStructClass, "<init>",
+        jmethodID testFabricScopedStructCtor_1 = env->GetMethodID(
+            testFabricScopedStructClass_1, "<init>",
             "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/lang/Integer;Ljava/util/Optional;Ljava/lang/String;Lchip/"
             "devicecontroller/ChipStructs$TestClusterClusterSimpleStruct;Ljava/util/ArrayList;Ljava/lang/Integer;)V");
-        if (testFabricScopedStructCtor == nullptr)
+        if (testFabricScopedStructCtor_1 == nullptr)
         {
             ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterTestFabricScoped constructor");
             return;
         }
 
         newElement_0 =
-            env->NewObject(testFabricScopedStructClass, testFabricScopedStructCtor, newElement_0_fabricSensitiveInt8u,
+            env->NewObject(testFabricScopedStructClass_1, testFabricScopedStructCtor_1, newElement_0_fabricSensitiveInt8u,
                            newElement_0_optionalFabricSensitiveInt8u, newElement_0_nullableFabricSensitiveInt8u,
                            newElement_0_nullableOptionalFabricSensitiveInt8u, newElement_0_fabricSensitiveCharString,
                            newElement_0_fabricSensitiveStruct, newElement_0_fabricSensitiveInt8uList, newElement_0_fabricIndex);
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java
new file mode 100644
index 00000000000000..aac77c2687c54b
--- /dev/null
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java
@@ -0,0 +1,1268 @@
+/*
+ *
+ *    Copyright (c) 2022 Project CHIP Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+package chip.devicecontroller;
+
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Optional;
+
+public class ChipEventStructs {
+  public static class AccessControlClusterAccessControlEntryChangedEvent {
+    public @Nullable Long adminNodeID;
+    public @Nullable Integer adminPasscodeID;
+    public Integer changeType;
+    public @Nullable ChipStructs.AccessControlClusterAccessControlEntry latestValue;
+    public Integer adminFabricIndex;
+
+    public AccessControlClusterAccessControlEntryChangedEvent(
+        @Nullable Long adminNodeID,
+        @Nullable Integer adminPasscodeID,
+        Integer changeType,
+        @Nullable ChipStructs.AccessControlClusterAccessControlEntry latestValue,
+        Integer adminFabricIndex) {
+      this.adminNodeID = adminNodeID;
+      this.adminPasscodeID = adminPasscodeID;
+      this.changeType = changeType;
+      this.latestValue = latestValue;
+      this.adminFabricIndex = adminFabricIndex;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("AccessControlClusterAccessControlEntryChangedEvent {\n");
+      output.append("\tadminNodeID: ");
+      output.append(adminNodeID);
+      output.append("\n");
+      output.append("\tadminPasscodeID: ");
+      output.append(adminPasscodeID);
+      output.append("\n");
+      output.append("\tchangeType: ");
+      output.append(changeType);
+      output.append("\n");
+      output.append("\tlatestValue: ");
+      output.append(latestValue);
+      output.append("\n");
+      output.append("\tadminFabricIndex: ");
+      output.append(adminFabricIndex);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class AccessControlClusterAccessControlExtensionChangedEvent {
+    public @Nullable Long adminNodeID;
+    public @Nullable Integer adminPasscodeID;
+    public Integer changeType;
+    public @Nullable ChipStructs.AccessControlClusterExtensionEntry latestValue;
+    public Integer adminFabricIndex;
+
+    public AccessControlClusterAccessControlExtensionChangedEvent(
+        @Nullable Long adminNodeID,
+        @Nullable Integer adminPasscodeID,
+        Integer changeType,
+        @Nullable ChipStructs.AccessControlClusterExtensionEntry latestValue,
+        Integer adminFabricIndex) {
+      this.adminNodeID = adminNodeID;
+      this.adminPasscodeID = adminPasscodeID;
+      this.changeType = changeType;
+      this.latestValue = latestValue;
+      this.adminFabricIndex = adminFabricIndex;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("AccessControlClusterAccessControlExtensionChangedEvent {\n");
+      output.append("\tadminNodeID: ");
+      output.append(adminNodeID);
+      output.append("\n");
+      output.append("\tadminPasscodeID: ");
+      output.append(adminPasscodeID);
+      output.append("\n");
+      output.append("\tchangeType: ");
+      output.append(changeType);
+      output.append("\n");
+      output.append("\tlatestValue: ");
+      output.append(latestValue);
+      output.append("\n");
+      output.append("\tadminFabricIndex: ");
+      output.append(adminFabricIndex);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BridgedActionsClusterStateChangedEvent {
+    public Integer actionID;
+    public Long invokeID;
+    public Integer newState;
+
+    public BridgedActionsClusterStateChangedEvent(
+        Integer actionID, Long invokeID, Integer newState) {
+      this.actionID = actionID;
+      this.invokeID = invokeID;
+      this.newState = newState;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BridgedActionsClusterStateChangedEvent {\n");
+      output.append("\tactionID: ");
+      output.append(actionID);
+      output.append("\n");
+      output.append("\tinvokeID: ");
+      output.append(invokeID);
+      output.append("\n");
+      output.append("\tnewState: ");
+      output.append(newState);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BridgedActionsClusterActionFailedEvent {
+    public Integer actionID;
+    public Long invokeID;
+    public Integer newState;
+    public Integer error;
+
+    public BridgedActionsClusterActionFailedEvent(
+        Integer actionID, Long invokeID, Integer newState, Integer error) {
+      this.actionID = actionID;
+      this.invokeID = invokeID;
+      this.newState = newState;
+      this.error = error;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BridgedActionsClusterActionFailedEvent {\n");
+      output.append("\tactionID: ");
+      output.append(actionID);
+      output.append("\n");
+      output.append("\tinvokeID: ");
+      output.append(invokeID);
+      output.append("\n");
+      output.append("\tnewState: ");
+      output.append(newState);
+      output.append("\n");
+      output.append("\terror: ");
+      output.append(error);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BasicClusterStartUpEvent {
+    public Long softwareVersion;
+
+    public BasicClusterStartUpEvent(Long softwareVersion) {
+      this.softwareVersion = softwareVersion;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BasicClusterStartUpEvent {\n");
+      output.append("\tsoftwareVersion: ");
+      output.append(softwareVersion);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BasicClusterShutDownEvent {
+
+    public BasicClusterShutDownEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BasicClusterShutDownEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BasicClusterLeaveEvent {
+
+    public BasicClusterLeaveEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BasicClusterLeaveEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BasicClusterReachableChangedEvent {
+    public Boolean reachableNewValue;
+
+    public BasicClusterReachableChangedEvent(Boolean reachableNewValue) {
+      this.reachableNewValue = reachableNewValue;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BasicClusterReachableChangedEvent {\n");
+      output.append("\treachableNewValue: ");
+      output.append(reachableNewValue);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class OtaSoftwareUpdateRequestorClusterStateTransitionEvent {
+    public Integer previousState;
+    public Integer newState;
+    public Integer reason;
+    public @Nullable Long targetSoftwareVersion;
+
+    public OtaSoftwareUpdateRequestorClusterStateTransitionEvent(
+        Integer previousState,
+        Integer newState,
+        Integer reason,
+        @Nullable Long targetSoftwareVersion) {
+      this.previousState = previousState;
+      this.newState = newState;
+      this.reason = reason;
+      this.targetSoftwareVersion = targetSoftwareVersion;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("OtaSoftwareUpdateRequestorClusterStateTransitionEvent {\n");
+      output.append("\tpreviousState: ");
+      output.append(previousState);
+      output.append("\n");
+      output.append("\tnewState: ");
+      output.append(newState);
+      output.append("\n");
+      output.append("\treason: ");
+      output.append(reason);
+      output.append("\n");
+      output.append("\ttargetSoftwareVersion: ");
+      output.append(targetSoftwareVersion);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class OtaSoftwareUpdateRequestorClusterVersionAppliedEvent {
+    public Long softwareVersion;
+    public Integer productID;
+
+    public OtaSoftwareUpdateRequestorClusterVersionAppliedEvent(
+        Long softwareVersion, Integer productID) {
+      this.softwareVersion = softwareVersion;
+      this.productID = productID;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("OtaSoftwareUpdateRequestorClusterVersionAppliedEvent {\n");
+      output.append("\tsoftwareVersion: ");
+      output.append(softwareVersion);
+      output.append("\n");
+      output.append("\tproductID: ");
+      output.append(productID);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class OtaSoftwareUpdateRequestorClusterDownloadErrorEvent {
+    public Long softwareVersion;
+    public Long bytesDownloaded;
+    public @Nullable Integer progressPercent;
+    public @Nullable Long platformCode;
+
+    public OtaSoftwareUpdateRequestorClusterDownloadErrorEvent(
+        Long softwareVersion,
+        Long bytesDownloaded,
+        @Nullable Integer progressPercent,
+        @Nullable Long platformCode) {
+      this.softwareVersion = softwareVersion;
+      this.bytesDownloaded = bytesDownloaded;
+      this.progressPercent = progressPercent;
+      this.platformCode = platformCode;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("OtaSoftwareUpdateRequestorClusterDownloadErrorEvent {\n");
+      output.append("\tsoftwareVersion: ");
+      output.append(softwareVersion);
+      output.append("\n");
+      output.append("\tbytesDownloaded: ");
+      output.append(bytesDownloaded);
+      output.append("\n");
+      output.append("\tprogressPercent: ");
+      output.append(progressPercent);
+      output.append("\n");
+      output.append("\tplatformCode: ");
+      output.append(platformCode);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class GeneralDiagnosticsClusterHardwareFaultChangeEvent {
+    public ArrayList<Object> current;
+    public ArrayList<Object> previous;
+
+    public GeneralDiagnosticsClusterHardwareFaultChangeEvent(
+        ArrayList<Object> current, ArrayList<Object> previous) {
+      this.current = current;
+      this.previous = previous;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("GeneralDiagnosticsClusterHardwareFaultChangeEvent {\n");
+      output.append("\tcurrent: ");
+      output.append(current);
+      output.append("\n");
+      output.append("\tprevious: ");
+      output.append(previous);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class GeneralDiagnosticsClusterRadioFaultChangeEvent {
+    public ArrayList<Object> current;
+    public ArrayList<Object> previous;
+
+    public GeneralDiagnosticsClusterRadioFaultChangeEvent(
+        ArrayList<Object> current, ArrayList<Object> previous) {
+      this.current = current;
+      this.previous = previous;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("GeneralDiagnosticsClusterRadioFaultChangeEvent {\n");
+      output.append("\tcurrent: ");
+      output.append(current);
+      output.append("\n");
+      output.append("\tprevious: ");
+      output.append(previous);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class GeneralDiagnosticsClusterNetworkFaultChangeEvent {
+    public ArrayList<Object> current;
+    public ArrayList<Object> previous;
+
+    public GeneralDiagnosticsClusterNetworkFaultChangeEvent(
+        ArrayList<Object> current, ArrayList<Object> previous) {
+      this.current = current;
+      this.previous = previous;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("GeneralDiagnosticsClusterNetworkFaultChangeEvent {\n");
+      output.append("\tcurrent: ");
+      output.append(current);
+      output.append("\n");
+      output.append("\tprevious: ");
+      output.append(previous);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class GeneralDiagnosticsClusterBootReasonEvent {
+    public Integer bootReason;
+
+    public GeneralDiagnosticsClusterBootReasonEvent(Integer bootReason) {
+      this.bootReason = bootReason;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("GeneralDiagnosticsClusterBootReasonEvent {\n");
+      output.append("\tbootReason: ");
+      output.append(bootReason);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class SoftwareDiagnosticsClusterSoftwareFaultEvent {
+    public Long id;
+    public Optional<String> name;
+    public Optional<byte[]> faultRecording;
+
+    public SoftwareDiagnosticsClusterSoftwareFaultEvent(
+        Long id, Optional<String> name, Optional<byte[]> faultRecording) {
+      this.id = id;
+      this.name = name;
+      this.faultRecording = faultRecording;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("SoftwareDiagnosticsClusterSoftwareFaultEvent {\n");
+      output.append("\tid: ");
+      output.append(id);
+      output.append("\n");
+      output.append("\tname: ");
+      output.append(name);
+      output.append("\n");
+      output.append("\tfaultRecording: ");
+      output.append(faultRecording.isPresent() ? Arrays.toString(faultRecording.get()) : "");
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class ThreadNetworkDiagnosticsClusterConnectionStatusEvent {
+    public Integer connectionStatus;
+
+    public ThreadNetworkDiagnosticsClusterConnectionStatusEvent(Integer connectionStatus) {
+      this.connectionStatus = connectionStatus;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("ThreadNetworkDiagnosticsClusterConnectionStatusEvent {\n");
+      output.append("\tconnectionStatus: ");
+      output.append(connectionStatus);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class WiFiNetworkDiagnosticsClusterDisconnectionEvent {
+    public Integer reasonCode;
+
+    public WiFiNetworkDiagnosticsClusterDisconnectionEvent(Integer reasonCode) {
+      this.reasonCode = reasonCode;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("WiFiNetworkDiagnosticsClusterDisconnectionEvent {\n");
+      output.append("\treasonCode: ");
+      output.append(reasonCode);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class WiFiNetworkDiagnosticsClusterAssociationFailureEvent {
+    public Integer associationFailure;
+    public Integer status;
+
+    public WiFiNetworkDiagnosticsClusterAssociationFailureEvent(
+        Integer associationFailure, Integer status) {
+      this.associationFailure = associationFailure;
+      this.status = status;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("WiFiNetworkDiagnosticsClusterAssociationFailureEvent {\n");
+      output.append("\tassociationFailure: ");
+      output.append(associationFailure);
+      output.append("\n");
+      output.append("\tstatus: ");
+      output.append(status);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class WiFiNetworkDiagnosticsClusterConnectionStatusEvent {
+    public Integer connectionStatus;
+
+    public WiFiNetworkDiagnosticsClusterConnectionStatusEvent(Integer connectionStatus) {
+      this.connectionStatus = connectionStatus;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("WiFiNetworkDiagnosticsClusterConnectionStatusEvent {\n");
+      output.append("\tconnectionStatus: ");
+      output.append(connectionStatus);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BridgedDeviceBasicClusterStartUpEvent {
+    public Long softwareVersion;
+
+    public BridgedDeviceBasicClusterStartUpEvent(Long softwareVersion) {
+      this.softwareVersion = softwareVersion;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BridgedDeviceBasicClusterStartUpEvent {\n");
+      output.append("\tsoftwareVersion: ");
+      output.append(softwareVersion);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BridgedDeviceBasicClusterShutDownEvent {
+
+    public BridgedDeviceBasicClusterShutDownEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BridgedDeviceBasicClusterShutDownEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BridgedDeviceBasicClusterLeaveEvent {
+
+    public BridgedDeviceBasicClusterLeaveEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BridgedDeviceBasicClusterLeaveEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BridgedDeviceBasicClusterReachableChangedEvent {
+    public Boolean reachableNewValue;
+
+    public BridgedDeviceBasicClusterReachableChangedEvent(Boolean reachableNewValue) {
+      this.reachableNewValue = reachableNewValue;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BridgedDeviceBasicClusterReachableChangedEvent {\n");
+      output.append("\treachableNewValue: ");
+      output.append(reachableNewValue);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class SwitchClusterSwitchLatchedEvent {
+    public Integer newPosition;
+
+    public SwitchClusterSwitchLatchedEvent(Integer newPosition) {
+      this.newPosition = newPosition;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("SwitchClusterSwitchLatchedEvent {\n");
+      output.append("\tnewPosition: ");
+      output.append(newPosition);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class SwitchClusterInitialPressEvent {
+    public Integer newPosition;
+
+    public SwitchClusterInitialPressEvent(Integer newPosition) {
+      this.newPosition = newPosition;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("SwitchClusterInitialPressEvent {\n");
+      output.append("\tnewPosition: ");
+      output.append(newPosition);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class SwitchClusterLongPressEvent {
+    public Integer newPosition;
+
+    public SwitchClusterLongPressEvent(Integer newPosition) {
+      this.newPosition = newPosition;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("SwitchClusterLongPressEvent {\n");
+      output.append("\tnewPosition: ");
+      output.append(newPosition);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class SwitchClusterShortReleaseEvent {
+    public Integer previousPosition;
+
+    public SwitchClusterShortReleaseEvent(Integer previousPosition) {
+      this.previousPosition = previousPosition;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("SwitchClusterShortReleaseEvent {\n");
+      output.append("\tpreviousPosition: ");
+      output.append(previousPosition);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class SwitchClusterLongReleaseEvent {
+    public Integer previousPosition;
+
+    public SwitchClusterLongReleaseEvent(Integer previousPosition) {
+      this.previousPosition = previousPosition;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("SwitchClusterLongReleaseEvent {\n");
+      output.append("\tpreviousPosition: ");
+      output.append(previousPosition);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class SwitchClusterMultiPressOngoingEvent {
+    public Integer newPosition;
+    public Integer currentNumberOfPressesCounted;
+
+    public SwitchClusterMultiPressOngoingEvent(
+        Integer newPosition, Integer currentNumberOfPressesCounted) {
+      this.newPosition = newPosition;
+      this.currentNumberOfPressesCounted = currentNumberOfPressesCounted;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("SwitchClusterMultiPressOngoingEvent {\n");
+      output.append("\tnewPosition: ");
+      output.append(newPosition);
+      output.append("\n");
+      output.append("\tcurrentNumberOfPressesCounted: ");
+      output.append(currentNumberOfPressesCounted);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class SwitchClusterMultiPressCompleteEvent {
+    public Integer newPosition;
+    public Integer totalNumberOfPressesCounted;
+
+    public SwitchClusterMultiPressCompleteEvent(
+        Integer newPosition, Integer totalNumberOfPressesCounted) {
+      this.newPosition = newPosition;
+      this.totalNumberOfPressesCounted = totalNumberOfPressesCounted;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("SwitchClusterMultiPressCompleteEvent {\n");
+      output.append("\tnewPosition: ");
+      output.append(newPosition);
+      output.append("\n");
+      output.append("\ttotalNumberOfPressesCounted: ");
+      output.append(totalNumberOfPressesCounted);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class BooleanStateClusterStateChangeEvent {
+    public Boolean stateValue;
+
+    public BooleanStateClusterStateChangeEvent(Boolean stateValue) {
+      this.stateValue = stateValue;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("BooleanStateClusterStateChangeEvent {\n");
+      output.append("\tstateValue: ");
+      output.append(stateValue);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class DoorLockClusterDoorLockAlarmEvent {
+    public Integer alarmCode;
+
+    public DoorLockClusterDoorLockAlarmEvent(Integer alarmCode) {
+      this.alarmCode = alarmCode;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("DoorLockClusterDoorLockAlarmEvent {\n");
+      output.append("\talarmCode: ");
+      output.append(alarmCode);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class DoorLockClusterDoorStateChangeEvent {
+    public Integer doorState;
+
+    public DoorLockClusterDoorStateChangeEvent(Integer doorState) {
+      this.doorState = doorState;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("DoorLockClusterDoorStateChangeEvent {\n");
+      output.append("\tdoorState: ");
+      output.append(doorState);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class DoorLockClusterLockOperationEvent {
+    public Integer lockOperationType;
+    public Integer operationSource;
+    public @Nullable Integer userIndex;
+    public @Nullable Integer fabricIndex;
+    public @Nullable Long sourceNode;
+    public @Nullable Optional<ArrayList<ChipStructs.DoorLockClusterDlCredential>> credentials;
+
+    public DoorLockClusterLockOperationEvent(
+        Integer lockOperationType,
+        Integer operationSource,
+        @Nullable Integer userIndex,
+        @Nullable Integer fabricIndex,
+        @Nullable Long sourceNode,
+        @Nullable Optional<ArrayList<ChipStructs.DoorLockClusterDlCredential>> credentials) {
+      this.lockOperationType = lockOperationType;
+      this.operationSource = operationSource;
+      this.userIndex = userIndex;
+      this.fabricIndex = fabricIndex;
+      this.sourceNode = sourceNode;
+      this.credentials = credentials;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("DoorLockClusterLockOperationEvent {\n");
+      output.append("\tlockOperationType: ");
+      output.append(lockOperationType);
+      output.append("\n");
+      output.append("\toperationSource: ");
+      output.append(operationSource);
+      output.append("\n");
+      output.append("\tuserIndex: ");
+      output.append(userIndex);
+      output.append("\n");
+      output.append("\tfabricIndex: ");
+      output.append(fabricIndex);
+      output.append("\n");
+      output.append("\tsourceNode: ");
+      output.append(sourceNode);
+      output.append("\n");
+      output.append("\tcredentials: ");
+      output.append(credentials);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class DoorLockClusterLockOperationErrorEvent {
+    public Integer lockOperationType;
+    public Integer operationSource;
+    public Integer operationError;
+    public @Nullable Integer userIndex;
+    public @Nullable Integer fabricIndex;
+    public @Nullable Long sourceNode;
+    public @Nullable Optional<ArrayList<ChipStructs.DoorLockClusterDlCredential>> credentials;
+
+    public DoorLockClusterLockOperationErrorEvent(
+        Integer lockOperationType,
+        Integer operationSource,
+        Integer operationError,
+        @Nullable Integer userIndex,
+        @Nullable Integer fabricIndex,
+        @Nullable Long sourceNode,
+        @Nullable Optional<ArrayList<ChipStructs.DoorLockClusterDlCredential>> credentials) {
+      this.lockOperationType = lockOperationType;
+      this.operationSource = operationSource;
+      this.operationError = operationError;
+      this.userIndex = userIndex;
+      this.fabricIndex = fabricIndex;
+      this.sourceNode = sourceNode;
+      this.credentials = credentials;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("DoorLockClusterLockOperationErrorEvent {\n");
+      output.append("\tlockOperationType: ");
+      output.append(lockOperationType);
+      output.append("\n");
+      output.append("\toperationSource: ");
+      output.append(operationSource);
+      output.append("\n");
+      output.append("\toperationError: ");
+      output.append(operationError);
+      output.append("\n");
+      output.append("\tuserIndex: ");
+      output.append(userIndex);
+      output.append("\n");
+      output.append("\tfabricIndex: ");
+      output.append(fabricIndex);
+      output.append("\n");
+      output.append("\tsourceNode: ");
+      output.append(sourceNode);
+      output.append("\n");
+      output.append("\tcredentials: ");
+      output.append(credentials);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class DoorLockClusterLockUserChangeEvent {
+    public Integer lockDataType;
+    public Integer dataOperationType;
+    public Integer operationSource;
+    public @Nullable Integer userIndex;
+    public @Nullable Integer fabricIndex;
+    public @Nullable Long sourceNode;
+    public @Nullable Integer dataIndex;
+
+    public DoorLockClusterLockUserChangeEvent(
+        Integer lockDataType,
+        Integer dataOperationType,
+        Integer operationSource,
+        @Nullable Integer userIndex,
+        @Nullable Integer fabricIndex,
+        @Nullable Long sourceNode,
+        @Nullable Integer dataIndex) {
+      this.lockDataType = lockDataType;
+      this.dataOperationType = dataOperationType;
+      this.operationSource = operationSource;
+      this.userIndex = userIndex;
+      this.fabricIndex = fabricIndex;
+      this.sourceNode = sourceNode;
+      this.dataIndex = dataIndex;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("DoorLockClusterLockUserChangeEvent {\n");
+      output.append("\tlockDataType: ");
+      output.append(lockDataType);
+      output.append("\n");
+      output.append("\tdataOperationType: ");
+      output.append(dataOperationType);
+      output.append("\n");
+      output.append("\toperationSource: ");
+      output.append(operationSource);
+      output.append("\n");
+      output.append("\tuserIndex: ");
+      output.append(userIndex);
+      output.append("\n");
+      output.append("\tfabricIndex: ");
+      output.append(fabricIndex);
+      output.append("\n");
+      output.append("\tsourceNode: ");
+      output.append(sourceNode);
+      output.append("\n");
+      output.append("\tdataIndex: ");
+      output.append(dataIndex);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterSupplyVoltageLowEvent {
+
+    public PumpConfigurationAndControlClusterSupplyVoltageLowEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterSupplyVoltageLowEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterSupplyVoltageHighEvent {
+
+    public PumpConfigurationAndControlClusterSupplyVoltageHighEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterSupplyVoltageHighEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterPowerMissingPhaseEvent {
+
+    public PumpConfigurationAndControlClusterPowerMissingPhaseEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterPowerMissingPhaseEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterSystemPressureLowEvent {
+
+    public PumpConfigurationAndControlClusterSystemPressureLowEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterSystemPressureLowEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterSystemPressureHighEvent {
+
+    public PumpConfigurationAndControlClusterSystemPressureHighEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterSystemPressureHighEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterDryRunningEvent {
+
+    public PumpConfigurationAndControlClusterDryRunningEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterDryRunningEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterMotorTemperatureHighEvent {
+
+    public PumpConfigurationAndControlClusterMotorTemperatureHighEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterMotorTemperatureHighEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent {
+
+    public PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterElectronicTemperatureHighEvent {
+
+    public PumpConfigurationAndControlClusterElectronicTemperatureHighEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterElectronicTemperatureHighEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterPumpBlockedEvent {
+
+    public PumpConfigurationAndControlClusterPumpBlockedEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterPumpBlockedEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterSensorFailureEvent {
+
+    public PumpConfigurationAndControlClusterSensorFailureEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterSensorFailureEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent {
+
+    public PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterElectronicFatalFailureEvent {
+
+    public PumpConfigurationAndControlClusterElectronicFatalFailureEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterElectronicFatalFailureEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterGeneralFaultEvent {
+
+    public PumpConfigurationAndControlClusterGeneralFaultEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterGeneralFaultEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterLeakageEvent {
+
+    public PumpConfigurationAndControlClusterLeakageEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterLeakageEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterAirDetectionEvent {
+
+    public PumpConfigurationAndControlClusterAirDetectionEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterAirDetectionEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class PumpConfigurationAndControlClusterTurbineOperationEvent {
+
+    public PumpConfigurationAndControlClusterTurbineOperationEvent() {}
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("PumpConfigurationAndControlClusterTurbineOperationEvent {\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class TestClusterClusterTestEventEvent {
+    public Integer arg1;
+    public Integer arg2;
+    public Boolean arg3;
+    public ChipStructs.TestClusterClusterSimpleStruct arg4;
+    public ArrayList<ChipStructs.TestClusterClusterSimpleStruct> arg5;
+    public ArrayList<Object> arg6;
+
+    public TestClusterClusterTestEventEvent(
+        Integer arg1,
+        Integer arg2,
+        Boolean arg3,
+        ChipStructs.TestClusterClusterSimpleStruct arg4,
+        ArrayList<ChipStructs.TestClusterClusterSimpleStruct> arg5,
+        ArrayList<Object> arg6) {
+      this.arg1 = arg1;
+      this.arg2 = arg2;
+      this.arg3 = arg3;
+      this.arg4 = arg4;
+      this.arg5 = arg5;
+      this.arg6 = arg6;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("TestClusterClusterTestEventEvent {\n");
+      output.append("\targ1: ");
+      output.append(arg1);
+      output.append("\n");
+      output.append("\targ2: ");
+      output.append(arg2);
+      output.append("\n");
+      output.append("\targ3: ");
+      output.append(arg3);
+      output.append("\n");
+      output.append("\targ4: ");
+      output.append(arg4);
+      output.append("\n");
+      output.append("\targ5: ");
+      output.append(arg5);
+      output.append("\n");
+      output.append("\targ6: ");
+      output.append(arg6);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+
+  public static class TestClusterClusterTestFabricScopedEventEvent {
+    public Integer arg1;
+
+    public TestClusterClusterTestFabricScopedEventEvent(Integer arg1) {
+      this.arg1 = arg1;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder output = new StringBuilder();
+      output.append("TestClusterClusterTestFabricScopedEventEvent {\n");
+      output.append("\targ1: ");
+      output.append(arg1);
+      output.append("\n");
+      output.append("}\n");
+      return output.toString();
+    }
+  }
+}
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java
index 811d6f4ebcf382..8dc95291d336f7 100644
--- a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java
@@ -3026,4 +3026,372 @@ public static String attributeIdToName(long clusterId, long attributeId) {
     }
     return "";
   }
+
+  /**
+   * Translates cluster ID and event ID to an attribute name in upper camel case. If no matching IDs
+   * are found, returns an empty string.
+   */
+  public static String eventIdToName(long clusterId, long eventId) {
+    if (clusterId == 3L) {
+      return "";
+    }
+    if (clusterId == 4L) {
+      return "";
+    }
+    if (clusterId == 5L) {
+      return "";
+    }
+    if (clusterId == 6L) {
+      return "";
+    }
+    if (clusterId == 7L) {
+      return "";
+    }
+    if (clusterId == 8L) {
+      return "";
+    }
+    if (clusterId == 15L) {
+      return "";
+    }
+    if (clusterId == 29L) {
+      return "";
+    }
+    if (clusterId == 30L) {
+      return "";
+    }
+    if (clusterId == 31L) {
+      if (eventId == 0L) {
+        return "AccessControlEntryChanged";
+      }
+      if (eventId == 1L) {
+        return "AccessControlExtensionChanged";
+      }
+      return "";
+    }
+    if (clusterId == 37L) {
+      if (eventId == 0L) {
+        return "StateChanged";
+      }
+      if (eventId == 1L) {
+        return "ActionFailed";
+      }
+      return "";
+    }
+    if (clusterId == 40L) {
+      if (eventId == 0L) {
+        return "StartUp";
+      }
+      if (eventId == 1L) {
+        return "ShutDown";
+      }
+      if (eventId == 2L) {
+        return "Leave";
+      }
+      if (eventId == 3L) {
+        return "ReachableChanged";
+      }
+      return "";
+    }
+    if (clusterId == 41L) {
+      return "";
+    }
+    if (clusterId == 42L) {
+      if (eventId == 0L) {
+        return "StateTransition";
+      }
+      if (eventId == 1L) {
+        return "VersionApplied";
+      }
+      if (eventId == 2L) {
+        return "DownloadError";
+      }
+      return "";
+    }
+    if (clusterId == 43L) {
+      return "";
+    }
+    if (clusterId == 44L) {
+      return "";
+    }
+    if (clusterId == 45L) {
+      return "";
+    }
+    if (clusterId == 46L) {
+      return "";
+    }
+    if (clusterId == 47L) {
+      return "";
+    }
+    if (clusterId == 48L) {
+      return "";
+    }
+    if (clusterId == 49L) {
+      return "";
+    }
+    if (clusterId == 50L) {
+      return "";
+    }
+    if (clusterId == 51L) {
+      if (eventId == 0L) {
+        return "HardwareFaultChange";
+      }
+      if (eventId == 1L) {
+        return "RadioFaultChange";
+      }
+      if (eventId == 2L) {
+        return "NetworkFaultChange";
+      }
+      if (eventId == 3L) {
+        return "BootReason";
+      }
+      return "";
+    }
+    if (clusterId == 52L) {
+      if (eventId == 0L) {
+        return "SoftwareFault";
+      }
+      return "";
+    }
+    if (clusterId == 53L) {
+      if (eventId == 0L) {
+        return "ConnectionStatus";
+      }
+      return "";
+    }
+    if (clusterId == 54L) {
+      if (eventId == 0L) {
+        return "Disconnection";
+      }
+      if (eventId == 1L) {
+        return "AssociationFailure";
+      }
+      if (eventId == 2L) {
+        return "ConnectionStatus";
+      }
+      return "";
+    }
+    if (clusterId == 55L) {
+      return "";
+    }
+    if (clusterId == 57L) {
+      if (eventId == 0L) {
+        return "StartUp";
+      }
+      if (eventId == 1L) {
+        return "ShutDown";
+      }
+      if (eventId == 2L) {
+        return "Leave";
+      }
+      if (eventId == 3L) {
+        return "ReachableChanged";
+      }
+      return "";
+    }
+    if (clusterId == 59L) {
+      if (eventId == 0L) {
+        return "SwitchLatched";
+      }
+      if (eventId == 1L) {
+        return "InitialPress";
+      }
+      if (eventId == 2L) {
+        return "LongPress";
+      }
+      if (eventId == 3L) {
+        return "ShortRelease";
+      }
+      if (eventId == 4L) {
+        return "LongRelease";
+      }
+      if (eventId == 5L) {
+        return "MultiPressOngoing";
+      }
+      if (eventId == 6L) {
+        return "MultiPressComplete";
+      }
+      return "";
+    }
+    if (clusterId == 60L) {
+      return "";
+    }
+    if (clusterId == 62L) {
+      return "";
+    }
+    if (clusterId == 63L) {
+      return "";
+    }
+    if (clusterId == 64L) {
+      return "";
+    }
+    if (clusterId == 65L) {
+      return "";
+    }
+    if (clusterId == 69L) {
+      if (eventId == 0L) {
+        return "StateChange";
+      }
+      return "";
+    }
+    if (clusterId == 80L) {
+      return "";
+    }
+    if (clusterId == 257L) {
+      if (eventId == 0L) {
+        return "DoorLockAlarm";
+      }
+      if (eventId == 1L) {
+        return "DoorStateChange";
+      }
+      if (eventId == 2L) {
+        return "LockOperation";
+      }
+      if (eventId == 3L) {
+        return "LockOperationError";
+      }
+      if (eventId == 4L) {
+        return "LockUserChange";
+      }
+      return "";
+    }
+    if (clusterId == 258L) {
+      return "";
+    }
+    if (clusterId == 259L) {
+      return "";
+    }
+    if (clusterId == 512L) {
+      if (eventId == 0L) {
+        return "SupplyVoltageLow";
+      }
+      if (eventId == 1L) {
+        return "SupplyVoltageHigh";
+      }
+      if (eventId == 2L) {
+        return "PowerMissingPhase";
+      }
+      if (eventId == 3L) {
+        return "SystemPressureLow";
+      }
+      if (eventId == 4L) {
+        return "SystemPressureHigh";
+      }
+      if (eventId == 5L) {
+        return "DryRunning";
+      }
+      if (eventId == 6L) {
+        return "MotorTemperatureHigh";
+      }
+      if (eventId == 7L) {
+        return "PumpMotorFatalFailure";
+      }
+      if (eventId == 8L) {
+        return "ElectronicTemperatureHigh";
+      }
+      if (eventId == 9L) {
+        return "PumpBlocked";
+      }
+      if (eventId == 10L) {
+        return "SensorFailure";
+      }
+      if (eventId == 11L) {
+        return "ElectronicNonFatalFailure";
+      }
+      if (eventId == 12L) {
+        return "ElectronicFatalFailure";
+      }
+      if (eventId == 13L) {
+        return "GeneralFault";
+      }
+      if (eventId == 14L) {
+        return "Leakage";
+      }
+      if (eventId == 15L) {
+        return "AirDetection";
+      }
+      if (eventId == 16L) {
+        return "TurbineOperation";
+      }
+      return "";
+    }
+    if (clusterId == 513L) {
+      return "";
+    }
+    if (clusterId == 514L) {
+      return "";
+    }
+    if (clusterId == 516L) {
+      return "";
+    }
+    if (clusterId == 768L) {
+      return "";
+    }
+    if (clusterId == 1024L) {
+      return "";
+    }
+    if (clusterId == 1026L) {
+      return "";
+    }
+    if (clusterId == 1027L) {
+      return "";
+    }
+    if (clusterId == 1028L) {
+      return "";
+    }
+    if (clusterId == 1029L) {
+      return "";
+    }
+    if (clusterId == 1030L) {
+      return "";
+    }
+    if (clusterId == 1283L) {
+      return "";
+    }
+    if (clusterId == 1284L) {
+      return "";
+    }
+    if (clusterId == 1285L) {
+      return "";
+    }
+    if (clusterId == 1286L) {
+      return "";
+    }
+    if (clusterId == 1287L) {
+      return "";
+    }
+    if (clusterId == 1288L) {
+      return "";
+    }
+    if (clusterId == 1289L) {
+      return "";
+    }
+    if (clusterId == 1290L) {
+      return "";
+    }
+    if (clusterId == 1291L) {
+      return "";
+    }
+    if (clusterId == 1292L) {
+      return "";
+    }
+    if (clusterId == 1293L) {
+      return "";
+    }
+    if (clusterId == 1294L) {
+      return "";
+    }
+    if (clusterId == 2820L) {
+      return "";
+    }
+    if (clusterId == 4294048773L) {
+      if (eventId == 1L) {
+        return "TestEvent";
+      }
+      if (eventId == 2L) {
+        return "TestFabricScopedEvent";
+      }
+      return "";
+    }
+    return "";
+  }
 }