/*
 *
 *    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::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::PulseWidthModulation::Id: {
        using namespace app::Clusters::PulseWidthModulation;
        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";
                jlong jnivalue_adminNodeID                 = static_cast<jlong>(cppValue.adminNodeID.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_adminNodeIDClassName.c_str(),
                                                                            value_adminNodeIDCtorSignature.c_str(),
                                                                            jnivalue_adminNodeID, 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";
                jint jnivalue_adminPasscodeID                  = static_cast<jint>(cppValue.adminPasscodeID.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_adminPasscodeIDClassName.c_str(),
                                                                           value_adminPasscodeIDCtorSignature.c_str(),
                                                                           jnivalue_adminPasscodeID, value_adminPasscodeID);
            }

            jobject value_changeType;
            std::string value_changeTypeClassName     = "java/lang/Integer";
            std::string value_changeTypeCtorSignature = "(I)V";
            jint jnivalue_changeType                  = static_cast<jint>(cppValue.changeType);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_changeTypeClassName.c_str(), value_changeTypeCtorSignature.c_str(), jnivalue_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";
                jint jnivalue_latestValue_privilege                  = static_cast<jint>(cppValue.latestValue.Value().privilege);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_latestValue_privilegeClassName.c_str(), value_latestValue_privilegeCtorSignature.c_str(),
                    jnivalue_latestValue_privilege, value_latestValue_privilege);
                jobject value_latestValue_authMode;
                std::string value_latestValue_authModeClassName     = "java/lang/Integer";
                std::string value_latestValue_authModeCtorSignature = "(I)V";
                jint jnivalue_latestValue_authMode                  = static_cast<jint>(cppValue.latestValue.Value().authMode);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_latestValue_authModeClassName.c_str(), value_latestValue_authModeCtorSignature.c_str(),
                    jnivalue_latestValue_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";
                        jlong jninewElement_3                 = static_cast<jlong>(entry_3);
                        chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                            newElement_3ClassName.c_str(), newElement_3CtorSignature.c_str(), jninewElement_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";
                            jlong jninewElement_3_cluster                 = static_cast<jlong>(entry_3.cluster.Value());
                            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                                newElement_3_clusterClassName.c_str(), newElement_3_clusterCtorSignature.c_str(),
                                jninewElement_3_cluster, 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";
                            jint jninewElement_3_endpoint                  = static_cast<jint>(entry_3.endpoint.Value());
                            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                                newElement_3_endpointClassName.c_str(), newElement_3_endpointCtorSignature.c_str(),
                                jninewElement_3_endpoint, 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";
                            jlong jninewElement_3_deviceType                 = static_cast<jlong>(entry_3.deviceType.Value());
                            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                                newElement_3_deviceTypeClassName.c_str(), newElement_3_deviceTypeCtorSignature.c_str(),
                                jninewElement_3_deviceType, newElement_3_deviceType);
                        }

                        jclass accessControlTargetStructStructClass_4;
                        err = chip::JniReferences::GetInstance().GetLocalClassRef(
                            env, "chip/devicecontroller/ChipStructs$AccessControlClusterAccessControlTargetStruct",
                            accessControlTargetStructStructClass_4);
                        if (err != CHIP_NO_ERROR)
                        {
                            ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterAccessControlTargetStruct");
                            return nullptr;
                        }

                        jmethodID accessControlTargetStructStructCtor_4;
                        err = chip::JniReferences::GetInstance().FindMethod(
                            env, accessControlTargetStructStructClass_4, "<init>",
                            "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V", &accessControlTargetStructStructCtor_4);
                        if (err != CHIP_NO_ERROR || accessControlTargetStructStructCtor_4 == nullptr)
                        {
                            ChipLogError(Zcl,
                                         "Could not find ChipStructs$AccessControlClusterAccessControlTargetStruct constructor");
                            return nullptr;
                        }

                        newElement_3 = env->NewObject(accessControlTargetStructStructClass_4, accessControlTargetStructStructCtor_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";
                jint jnivalue_latestValue_fabricIndex = static_cast<jint>(cppValue.latestValue.Value().fabricIndex);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_latestValue_fabricIndexClassName.c_str(), value_latestValue_fabricIndexCtorSignature.c_str(),
                    jnivalue_latestValue_fabricIndex, value_latestValue_fabricIndex);

                jclass accessControlEntryStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterAccessControlEntryStruct",
                    accessControlEntryStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterAccessControlEntryStruct");
                    return nullptr;
                }

                jmethodID accessControlEntryStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(
                    env, accessControlEntryStructStructClass_1, "<init>",
                    "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/ArrayList;Ljava/util/ArrayList;Ljava/lang/Integer;)V",
                    &accessControlEntryStructStructCtor_1);
                if (err != CHIP_NO_ERROR || accessControlEntryStructStructCtor_1 == nullptr)
                {
                    ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterAccessControlEntryStruct constructor");
                    return nullptr;
                }

                value_latestValue =
                    env->NewObject(accessControlEntryStructStructClass_1, accessControlEntryStructStructCtor_1,
                                   value_latestValue_privilege, value_latestValue_authMode, value_latestValue_subjects,
                                   value_latestValue_targets, value_latestValue_fabricIndex);
            }

            jobject value_fabricIndex;
            std::string value_fabricIndexClassName     = "java/lang/Integer";
            std::string value_fabricIndexCtorSignature = "(I)V";
            jint jnivalue_fabricIndex                  = static_cast<jint>(cppValue.fabricIndex);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_fabricIndexClassName.c_str(),
                                                                       value_fabricIndexCtorSignature.c_str(), jnivalue_fabricIndex,
                                                                       value_fabricIndex);

            jclass accessControlEntryChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$AccessControlClusterAccessControlEntryChangedEvent",
                accessControlEntryChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$AccessControlClusterAccessControlEntryChangedEvent");
                return nullptr;
            }

            jmethodID accessControlEntryChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, accessControlEntryChangedStructClass, "<init>",
                "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Lchip/devicecontroller/"
                "ChipStructs$AccessControlClusterAccessControlEntryStruct;Ljava/lang/Integer;)V",
                &accessControlEntryChangedStructCtor);
            if (err != CHIP_NO_ERROR || 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_fabricIndex);

            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";
                jlong jnivalue_adminNodeID                 = static_cast<jlong>(cppValue.adminNodeID.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_adminNodeIDClassName.c_str(),
                                                                            value_adminNodeIDCtorSignature.c_str(),
                                                                            jnivalue_adminNodeID, 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";
                jint jnivalue_adminPasscodeID                  = static_cast<jint>(cppValue.adminPasscodeID.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_adminPasscodeIDClassName.c_str(),
                                                                           value_adminPasscodeIDCtorSignature.c_str(),
                                                                           jnivalue_adminPasscodeID, value_adminPasscodeID);
            }

            jobject value_changeType;
            std::string value_changeTypeClassName     = "java/lang/Integer";
            std::string value_changeTypeCtorSignature = "(I)V";
            jint jnivalue_changeType                  = static_cast<jint>(cppValue.changeType);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_changeTypeClassName.c_str(), value_changeTypeCtorSignature.c_str(), jnivalue_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";
                jint jnivalue_latestValue_fabricIndex = static_cast<jint>(cppValue.latestValue.Value().fabricIndex);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_latestValue_fabricIndexClassName.c_str(), value_latestValue_fabricIndexCtorSignature.c_str(),
                    jnivalue_latestValue_fabricIndex, value_latestValue_fabricIndex);

                jclass accessControlExtensionStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$AccessControlClusterAccessControlExtensionStruct",
                    accessControlExtensionStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$AccessControlClusterAccessControlExtensionStruct");
                    return nullptr;
                }

                jmethodID accessControlExtensionStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(env, accessControlExtensionStructStructClass_1, "<init>",
                                                                    "([BLjava/lang/Integer;)V",
                                                                    &accessControlExtensionStructStructCtor_1);
                if (err != CHIP_NO_ERROR || accessControlExtensionStructStructCtor_1 == nullptr)
                {
                    ChipLogError(Zcl, "Could not find ChipStructs$AccessControlClusterAccessControlExtensionStruct constructor");
                    return nullptr;
                }

                value_latestValue =
                    env->NewObject(accessControlExtensionStructStructClass_1, accessControlExtensionStructStructCtor_1,
                                   value_latestValue_data, value_latestValue_fabricIndex);
            }

            jobject value_fabricIndex;
            std::string value_fabricIndexClassName     = "java/lang/Integer";
            std::string value_fabricIndexCtorSignature = "(I)V";
            jint jnivalue_fabricIndex                  = static_cast<jint>(cppValue.fabricIndex);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_fabricIndexClassName.c_str(),
                                                                       value_fabricIndexCtorSignature.c_str(), jnivalue_fabricIndex,
                                                                       value_fabricIndex);

            jclass accessControlExtensionChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$AccessControlClusterAccessControlExtensionChangedEvent",
                accessControlExtensionChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$AccessControlClusterAccessControlExtensionChangedEvent");
                return nullptr;
            }

            jmethodID accessControlExtensionChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, accessControlExtensionChangedStructClass, "<init>",
                "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Lchip/devicecontroller/"
                "ChipStructs$AccessControlClusterAccessControlExtensionStruct;Ljava/lang/Integer;)V",
                &accessControlExtensionChangedStructCtor);
            if (err != CHIP_NO_ERROR || 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_fabricIndex);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::Actions::Id: {
        using namespace app::Clusters::Actions;
        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";
            jint jnivalue_actionID                  = static_cast<jint>(cppValue.actionID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_actionIDClassName.c_str(), value_actionIDCtorSignature.c_str(), jnivalue_actionID, value_actionID);

            jobject value_invokeID;
            std::string value_invokeIDClassName     = "java/lang/Long";
            std::string value_invokeIDCtorSignature = "(J)V";
            jlong jnivalue_invokeID                 = static_cast<jlong>(cppValue.invokeID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_invokeIDClassName.c_str(), value_invokeIDCtorSignature.c_str(), jnivalue_invokeID, value_invokeID);

            jobject value_newState;
            std::string value_newStateClassName     = "java/lang/Integer";
            std::string value_newStateCtorSignature = "(I)V";
            jint jnivalue_newState                  = static_cast<jint>(cppValue.newState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_newStateClassName.c_str(), value_newStateCtorSignature.c_str(), jnivalue_newState, value_newState);

            jclass stateChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ActionsClusterStateChangedEvent", stateChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$ActionsClusterStateChangedEvent");
                return nullptr;
            }

            jmethodID stateChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, stateChangedStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Integer;)V",
                                                                &stateChangedStructCtor);
            if (err != CHIP_NO_ERROR || stateChangedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$ActionsClusterStateChangedEvent 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";
            jint jnivalue_actionID                  = static_cast<jint>(cppValue.actionID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_actionIDClassName.c_str(), value_actionIDCtorSignature.c_str(), jnivalue_actionID, value_actionID);

            jobject value_invokeID;
            std::string value_invokeIDClassName     = "java/lang/Long";
            std::string value_invokeIDCtorSignature = "(J)V";
            jlong jnivalue_invokeID                 = static_cast<jlong>(cppValue.invokeID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_invokeIDClassName.c_str(), value_invokeIDCtorSignature.c_str(), jnivalue_invokeID, value_invokeID);

            jobject value_newState;
            std::string value_newStateClassName     = "java/lang/Integer";
            std::string value_newStateCtorSignature = "(I)V";
            jint jnivalue_newState                  = static_cast<jint>(cppValue.newState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_newStateClassName.c_str(), value_newStateCtorSignature.c_str(), jnivalue_newState, value_newState);

            jobject value_error;
            std::string value_errorClassName     = "java/lang/Integer";
            std::string value_errorCtorSignature = "(I)V";
            jint jnivalue_error                  = static_cast<jint>(cppValue.error);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_errorClassName.c_str(), value_errorCtorSignature.c_str(), jnivalue_error, value_error);

            jclass actionFailedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ActionsClusterActionFailedEvent", actionFailedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$ActionsClusterActionFailedEvent");
                return nullptr;
            }

            jmethodID actionFailedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, actionFailedStructClass, "<init>",
                "(Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;)V", &actionFailedStructCtor);
            if (err != CHIP_NO_ERROR || actionFailedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$ActionsClusterActionFailedEvent 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::BasicInformation::Id: {
        using namespace app::Clusters::BasicInformation;
        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";
            jlong jnivalue_softwareVersion                 = static_cast<jlong>(cppValue.softwareVersion);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_softwareVersionClassName.c_str(),
                                                                        value_softwareVersionCtorSignature.c_str(),
                                                                        jnivalue_softwareVersion, value_softwareVersion);

            jclass startUpStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BasicInformationClusterStartUpEvent", startUpStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BasicInformationClusterStartUpEvent");
                return nullptr;
            }

            jmethodID startUpStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, startUpStructClass, "<init>", "(Ljava/lang/Long;)V",
                                                                &startUpStructCtor);
            if (err != CHIP_NO_ERROR || startUpStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$BasicInformationClusterStartUpEvent 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BasicInformationClusterShutDownEvent", shutDownStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BasicInformationClusterShutDownEvent");
                return nullptr;
            }

            jmethodID shutDownStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, shutDownStructClass, "<init>", "()V", &shutDownStructCtor);
            if (err != CHIP_NO_ERROR || shutDownStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$BasicInformationClusterShutDownEvent 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;
            }
            jobject value_fabricIndex;
            std::string value_fabricIndexClassName     = "java/lang/Integer";
            std::string value_fabricIndexCtorSignature = "(I)V";
            jint jnivalue_fabricIndex                  = static_cast<jint>(cppValue.fabricIndex);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_fabricIndexClassName.c_str(),
                                                                       value_fabricIndexCtorSignature.c_str(), jnivalue_fabricIndex,
                                                                       value_fabricIndex);

            jclass leaveStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BasicInformationClusterLeaveEvent", leaveStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BasicInformationClusterLeaveEvent");
                return nullptr;
            }

            jmethodID leaveStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, leaveStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &leaveStructCtor);
            if (err != CHIP_NO_ERROR || leaveStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$BasicInformationClusterLeaveEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(leaveStructClass, leaveStructCtor, value_fabricIndex);

            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";
            jboolean jnivalue_reachableNewValue              = static_cast<jboolean>(cppValue.reachableNewValue);
            chip::JniReferences::GetInstance().CreateBoxedObject<jboolean>(value_reachableNewValueClassName.c_str(),
                                                                           value_reachableNewValueCtorSignature.c_str(),
                                                                           jnivalue_reachableNewValue, value_reachableNewValue);

            jclass reachableChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BasicInformationClusterReachableChangedEvent",
                reachableChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BasicInformationClusterReachableChangedEvent");
                return nullptr;
            }

            jmethodID reachableChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, reachableChangedStructClass, "<init>",
                                                                "(Ljava/lang/Boolean;)V", &reachableChangedStructCtor);
            if (err != CHIP_NO_ERROR || reachableChangedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$BasicInformationClusterReachableChangedEvent 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";
            jint jnivalue_previousState                  = static_cast<jint>(cppValue.previousState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_previousStateClassName.c_str(),
                                                                       value_previousStateCtorSignature.c_str(),
                                                                       jnivalue_previousState, value_previousState);

            jobject value_newState;
            std::string value_newStateClassName     = "java/lang/Integer";
            std::string value_newStateCtorSignature = "(I)V";
            jint jnivalue_newState                  = static_cast<jint>(cppValue.newState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_newStateClassName.c_str(), value_newStateCtorSignature.c_str(), jnivalue_newState, value_newState);

            jobject value_reason;
            std::string value_reasonClassName     = "java/lang/Integer";
            std::string value_reasonCtorSignature = "(I)V";
            jint jnivalue_reason                  = static_cast<jint>(cppValue.reason);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_reasonClassName.c_str(), value_reasonCtorSignature.c_str(), jnivalue_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";
                jlong jnivalue_targetSoftwareVersion                 = static_cast<jlong>(cppValue.targetSoftwareVersion.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                    value_targetSoftwareVersionClassName.c_str(), value_targetSoftwareVersionCtorSignature.c_str(),
                    jnivalue_targetSoftwareVersion, value_targetSoftwareVersion);
            }

            jclass stateTransitionStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$OtaSoftwareUpdateRequestorClusterStateTransitionEvent",
                stateTransitionStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$OtaSoftwareUpdateRequestorClusterStateTransitionEvent");
                return nullptr;
            }

            jmethodID stateTransitionStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, stateTransitionStructClass, "<init>",
                "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Long;)V", &stateTransitionStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jlong jnivalue_softwareVersion                 = static_cast<jlong>(cppValue.softwareVersion);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_softwareVersionClassName.c_str(),
                                                                        value_softwareVersionCtorSignature.c_str(),
                                                                        jnivalue_softwareVersion, value_softwareVersion);

            jobject value_productID;
            std::string value_productIDClassName     = "java/lang/Integer";
            std::string value_productIDCtorSignature = "(I)V";
            jint jnivalue_productID                  = static_cast<jint>(cppValue.productID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_productIDClassName.c_str(), value_productIDCtorSignature.c_str(), jnivalue_productID, value_productID);

            jclass versionAppliedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$OtaSoftwareUpdateRequestorClusterVersionAppliedEvent",
                versionAppliedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$OtaSoftwareUpdateRequestorClusterVersionAppliedEvent");
                return nullptr;
            }

            jmethodID versionAppliedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, versionAppliedStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;)V", &versionAppliedStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jlong jnivalue_softwareVersion                 = static_cast<jlong>(cppValue.softwareVersion);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_softwareVersionClassName.c_str(),
                                                                        value_softwareVersionCtorSignature.c_str(),
                                                                        jnivalue_softwareVersion, value_softwareVersion);

            jobject value_bytesDownloaded;
            std::string value_bytesDownloadedClassName     = "java/lang/Long";
            std::string value_bytesDownloadedCtorSignature = "(J)V";
            jlong jnivalue_bytesDownloaded                 = static_cast<jlong>(cppValue.bytesDownloaded);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_bytesDownloadedClassName.c_str(),
                                                                        value_bytesDownloadedCtorSignature.c_str(),
                                                                        jnivalue_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";
                jint jnivalue_progressPercent                  = static_cast<jint>(cppValue.progressPercent.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_progressPercentClassName.c_str(),
                                                                           value_progressPercentCtorSignature.c_str(),
                                                                           jnivalue_progressPercent, 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";
                jlong jnivalue_platformCode                 = static_cast<jlong>(cppValue.platformCode.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_platformCodeClassName.c_str(),
                                                                            value_platformCodeCtorSignature.c_str(),
                                                                            jnivalue_platformCode, value_platformCode);
            }

            jclass downloadErrorStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$OtaSoftwareUpdateRequestorClusterDownloadErrorEvent",
                downloadErrorStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$OtaSoftwareUpdateRequestorClusterDownloadErrorEvent");
                return nullptr;
            }

            jmethodID downloadErrorStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, downloadErrorStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V",
                &downloadErrorStructCtor);
            if (err != CHIP_NO_ERROR || 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)
        {
        case Events::WiredFaultChange::Id: {
            Events::WiredFaultChange::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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
            }

            jclass wiredFaultChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PowerSourceClusterWiredFaultChangeEvent", wiredFaultChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PowerSourceClusterWiredFaultChangeEvent");
                return nullptr;
            }

            jmethodID wiredFaultChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, wiredFaultChangeStructClass, "<init>",
                                                                "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V",
                                                                &wiredFaultChangeStructCtor);
            if (err != CHIP_NO_ERROR || wiredFaultChangeStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$PowerSourceClusterWiredFaultChangeEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(wiredFaultChangeStructClass, wiredFaultChangeStructCtor, value_current, value_previous);

            return value;
        }
        case Events::BatFaultChange::Id: {
            Events::BatFaultChange::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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
            }

            jclass batFaultChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PowerSourceClusterBatFaultChangeEvent", batFaultChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PowerSourceClusterBatFaultChangeEvent");
                return nullptr;
            }

            jmethodID batFaultChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, batFaultChangeStructClass, "<init>",
                                                                "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V",
                                                                &batFaultChangeStructCtor);
            if (err != CHIP_NO_ERROR || batFaultChangeStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$PowerSourceClusterBatFaultChangeEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(batFaultChangeStructClass, batFaultChangeStructCtor, value_current, value_previous);

            return value;
        }
        case Events::BatChargeFaultChange::Id: {
            Events::BatChargeFaultChange::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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
            }

            jclass batChargeFaultChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PowerSourceClusterBatChargeFaultChangeEvent",
                batChargeFaultChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PowerSourceClusterBatChargeFaultChangeEvent");
                return nullptr;
            }

            jmethodID batChargeFaultChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, batChargeFaultChangeStructClass, "<init>",
                                                                "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V",
                                                                &batChargeFaultChangeStructCtor);
            if (err != CHIP_NO_ERROR || batChargeFaultChangeStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$PowerSourceClusterBatChargeFaultChangeEvent constructor");
                return nullptr;
            }

            jobject value =
                env->NewObject(batChargeFaultChangeStructClass, batChargeFaultChangeStructCtor, value_current, value_previous);

            return value;
        }
        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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
            }

            jclass hardwareFaultChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$GeneralDiagnosticsClusterHardwareFaultChangeEvent",
                hardwareFaultChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$GeneralDiagnosticsClusterHardwareFaultChangeEvent");
                return nullptr;
            }

            jmethodID hardwareFaultChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, hardwareFaultChangeStructClass, "<init>",
                                                                "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V",
                                                                &hardwareFaultChangeStructCtor);
            if (err != CHIP_NO_ERROR || 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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
            }

            jclass radioFaultChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$GeneralDiagnosticsClusterRadioFaultChangeEvent",
                radioFaultChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$GeneralDiagnosticsClusterRadioFaultChangeEvent");
                return nullptr;
            }

            jmethodID radioFaultChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, radioFaultChangeStructClass, "<init>",
                                                                "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V",
                                                                &radioFaultChangeStructCtor);
            if (err != CHIP_NO_ERROR || 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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
            }

            jclass networkFaultChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$GeneralDiagnosticsClusterNetworkFaultChangeEvent",
                networkFaultChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$GeneralDiagnosticsClusterNetworkFaultChangeEvent");
                return nullptr;
            }

            jmethodID networkFaultChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, networkFaultChangeStructClass, "<init>",
                                                                "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V",
                                                                &networkFaultChangeStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_bootReason                  = static_cast<jint>(cppValue.bootReason);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_bootReasonClassName.c_str(), value_bootReasonCtorSignature.c_str(), jnivalue_bootReason, value_bootReason);

            jclass bootReasonStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$GeneralDiagnosticsClusterBootReasonEvent", bootReasonStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$GeneralDiagnosticsClusterBootReasonEvent");
                return nullptr;
            }

            jmethodID bootReasonStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, bootReasonStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &bootReasonStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jlong jnivalue_id                 = static_cast<jlong>(cppValue.id);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_idClassName.c_str(), value_idCtorSignature.c_str(),
                                                                        jnivalue_id, value_id);

            jobject value_name;
            if (!cppValue.name.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_name);
            }
            else
            {
                jobject value_nameInsideOptional;
                LogErrorOnFailure(
                    chip::JniReferences::GetInstance().CharToStringUTF(cppValue.name.Value(), value_nameInsideOptional));
                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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SoftwareDiagnosticsClusterSoftwareFaultEvent",
                softwareFaultStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SoftwareDiagnosticsClusterSoftwareFaultEvent");
                return nullptr;
            }

            jmethodID softwareFaultStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, softwareFaultStructClass, "<init>",
                                                                "(Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &softwareFaultStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_connectionStatus                  = static_cast<jint>(cppValue.connectionStatus);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_connectionStatusClassName.c_str(),
                                                                       value_connectionStatusCtorSignature.c_str(),
                                                                       jnivalue_connectionStatus, value_connectionStatus);

            jclass connectionStatusStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ThreadNetworkDiagnosticsClusterConnectionStatusEvent",
                connectionStatusStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$ThreadNetworkDiagnosticsClusterConnectionStatusEvent");
                return nullptr;
            }

            jmethodID connectionStatusStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, connectionStatusStructClass, "<init>",
                                                                "(Ljava/lang/Integer;)V", &connectionStatusStructCtor);
            if (err != CHIP_NO_ERROR || connectionStatusStructCtor == nullptr)
            {
                ChipLogError(Zcl,
                             "Could not find ChipEventStructs$ThreadNetworkDiagnosticsClusterConnectionStatusEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(connectionStatusStructClass, connectionStatusStructCtor, value_connectionStatus);

            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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
                chip::JniReferences::GetInstance().AddToList(value_previous, newElement_0);
            }

            jclass networkFaultChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent",
                networkFaultChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent");
                return nullptr;
            }

            jmethodID networkFaultChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, networkFaultChangeStructClass, "<init>",
                                                                "(Ljava/util/ArrayList;Ljava/util/ArrayList;)V",
                                                                &networkFaultChangeStructCtor);
            if (err != CHIP_NO_ERROR || networkFaultChangeStructCtor == nullptr)
            {
                ChipLogError(Zcl,
                             "Could not find ChipEventStructs$ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent constructor");
                return nullptr;
            }

            jobject value =
                env->NewObject(networkFaultChangeStructClass, networkFaultChangeStructCtor, value_current, value_previous);

            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";
            jint jnivalue_reasonCode                  = static_cast<jint>(cppValue.reasonCode);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_reasonCodeClassName.c_str(), value_reasonCodeCtorSignature.c_str(), jnivalue_reasonCode, value_reasonCode);

            jclass disconnectionStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$WiFiNetworkDiagnosticsClusterDisconnectionEvent",
                disconnectionStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$WiFiNetworkDiagnosticsClusterDisconnectionEvent");
                return nullptr;
            }

            jmethodID disconnectionStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, disconnectionStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &disconnectionStructCtor);
            if (err != CHIP_NO_ERROR || 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_associationFailureCause;
            std::string value_associationFailureCauseClassName     = "java/lang/Integer";
            std::string value_associationFailureCauseCtorSignature = "(I)V";
            jint jnivalue_associationFailureCause                  = static_cast<jint>(cppValue.associationFailureCause);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_associationFailureCauseClassName.c_str(), value_associationFailureCauseCtorSignature.c_str(),
                jnivalue_associationFailureCause, value_associationFailureCause);

            jobject value_status;
            std::string value_statusClassName     = "java/lang/Integer";
            std::string value_statusCtorSignature = "(I)V";
            jint jnivalue_status                  = static_cast<jint>(cppValue.status);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_statusClassName.c_str(), value_statusCtorSignature.c_str(), jnivalue_status, value_status);

            jclass associationFailureStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$WiFiNetworkDiagnosticsClusterAssociationFailureEvent",
                associationFailureStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$WiFiNetworkDiagnosticsClusterAssociationFailureEvent");
                return nullptr;
            }

            jmethodID associationFailureStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, associationFailureStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                                &associationFailureStructCtor);
            if (err != CHIP_NO_ERROR || associationFailureStructCtor == nullptr)
            {
                ChipLogError(Zcl,
                             "Could not find ChipEventStructs$WiFiNetworkDiagnosticsClusterAssociationFailureEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(associationFailureStructClass, associationFailureStructCtor,
                                           value_associationFailureCause, 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";
            jint jnivalue_connectionStatus                  = static_cast<jint>(cppValue.connectionStatus);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_connectionStatusClassName.c_str(),
                                                                       value_connectionStatusCtorSignature.c_str(),
                                                                       jnivalue_connectionStatus, value_connectionStatus);

            jclass connectionStatusStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$WiFiNetworkDiagnosticsClusterConnectionStatusEvent",
                connectionStatusStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$WiFiNetworkDiagnosticsClusterConnectionStatusEvent");
                return nullptr;
            }

            jmethodID connectionStatusStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, connectionStatusStructClass, "<init>",
                                                                "(Ljava/lang/Integer;)V", &connectionStatusStructCtor);
            if (err != CHIP_NO_ERROR || 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::TimeSynchronization::Id: {
        using namespace app::Clusters::TimeSynchronization;
        switch (aPath.mEventId)
        {
        case Events::DSTTableEmpty::Id: {
            Events::DSTTableEmpty::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass DSTTableEmptyStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$TimeSynchronizationClusterDSTTableEmptyEvent",
                DSTTableEmptyStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$TimeSynchronizationClusterDSTTableEmptyEvent");
                return nullptr;
            }

            jmethodID DSTTableEmptyStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, DSTTableEmptyStructClass, "<init>", "()V",
                                                                &DSTTableEmptyStructCtor);
            if (err != CHIP_NO_ERROR || DSTTableEmptyStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$TimeSynchronizationClusterDSTTableEmptyEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(DSTTableEmptyStructClass, DSTTableEmptyStructCtor);

            return value;
        }
        case Events::DSTStatus::Id: {
            Events::DSTStatus::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_DSTOffsetActive;
            std::string value_DSTOffsetActiveClassName     = "java/lang/Boolean";
            std::string value_DSTOffsetActiveCtorSignature = "(Z)V";
            jboolean jnivalue_DSTOffsetActive              = static_cast<jboolean>(cppValue.DSTOffsetActive);
            chip::JniReferences::GetInstance().CreateBoxedObject<jboolean>(value_DSTOffsetActiveClassName.c_str(),
                                                                           value_DSTOffsetActiveCtorSignature.c_str(),
                                                                           jnivalue_DSTOffsetActive, value_DSTOffsetActive);

            jclass DSTStatusStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$TimeSynchronizationClusterDSTStatusEvent", DSTStatusStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$TimeSynchronizationClusterDSTStatusEvent");
                return nullptr;
            }

            jmethodID DSTStatusStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, DSTStatusStructClass, "<init>", "(Ljava/lang/Boolean;)V",
                                                                &DSTStatusStructCtor);
            if (err != CHIP_NO_ERROR || DSTStatusStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$TimeSynchronizationClusterDSTStatusEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(DSTStatusStructClass, DSTStatusStructCtor, value_DSTOffsetActive);

            return value;
        }
        case Events::TimeZoneStatus::Id: {
            Events::TimeZoneStatus::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_offset;
            std::string value_offsetClassName     = "java/lang/Long";
            std::string value_offsetCtorSignature = "(J)V";
            jlong jnivalue_offset                 = static_cast<jlong>(cppValue.offset);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_offsetClassName.c_str(), value_offsetCtorSignature.c_str(), jnivalue_offset, value_offset);

            jobject value_name;
            if (!cppValue.name.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_name);
            }
            else
            {
                jobject value_nameInsideOptional;
                LogErrorOnFailure(
                    chip::JniReferences::GetInstance().CharToStringUTF(cppValue.name.Value(), value_nameInsideOptional));
                chip::JniReferences::GetInstance().CreateOptional(value_nameInsideOptional, value_name);
            }

            jclass timeZoneStatusStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$TimeSynchronizationClusterTimeZoneStatusEvent",
                timeZoneStatusStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$TimeSynchronizationClusterTimeZoneStatusEvent");
                return nullptr;
            }

            jmethodID timeZoneStatusStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, timeZoneStatusStructClass, "<init>", "(Ljava/lang/Long;Ljava/util/Optional;)V", &timeZoneStatusStructCtor);
            if (err != CHIP_NO_ERROR || timeZoneStatusStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$TimeSynchronizationClusterTimeZoneStatusEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(timeZoneStatusStructClass, timeZoneStatusStructCtor, value_offset, value_name);

            return value;
        }
        case Events::TimeFailure::Id: {
            Events::TimeFailure::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass timeFailureStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$TimeSynchronizationClusterTimeFailureEvent", timeFailureStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$TimeSynchronizationClusterTimeFailureEvent");
                return nullptr;
            }

            jmethodID timeFailureStructCtor;
            err =
                chip::JniReferences::GetInstance().FindMethod(env, timeFailureStructClass, "<init>", "()V", &timeFailureStructCtor);
            if (err != CHIP_NO_ERROR || timeFailureStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$TimeSynchronizationClusterTimeFailureEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(timeFailureStructClass, timeFailureStructCtor);

            return value;
        }
        case Events::MissingTrustedTimeSource::Id: {
            Events::MissingTrustedTimeSource::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass missingTrustedTimeSourceStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$TimeSynchronizationClusterMissingTrustedTimeSourceEvent",
                missingTrustedTimeSourceStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$TimeSynchronizationClusterMissingTrustedTimeSourceEvent");
                return nullptr;
            }

            jmethodID missingTrustedTimeSourceStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, missingTrustedTimeSourceStructClass, "<init>", "()V",
                                                                &missingTrustedTimeSourceStructCtor);
            if (err != CHIP_NO_ERROR || missingTrustedTimeSourceStructCtor == nullptr)
            {
                ChipLogError(Zcl,
                             "Could not find ChipEventStructs$TimeSynchronizationClusterMissingTrustedTimeSourceEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(missingTrustedTimeSourceStructClass, missingTrustedTimeSourceStructCtor);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::BridgedDeviceBasicInformation::Id: {
        using namespace app::Clusters::BridgedDeviceBasicInformation;
        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";
            jlong jnivalue_softwareVersion                 = static_cast<jlong>(cppValue.softwareVersion);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_softwareVersionClassName.c_str(),
                                                                        value_softwareVersionCtorSignature.c_str(),
                                                                        jnivalue_softwareVersion, value_softwareVersion);

            jclass startUpStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BridgedDeviceBasicInformationClusterStartUpEvent", startUpStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedDeviceBasicInformationClusterStartUpEvent");
                return nullptr;
            }

            jmethodID startUpStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, startUpStructClass, "<init>", "(Ljava/lang/Long;)V",
                                                                &startUpStructCtor);
            if (err != CHIP_NO_ERROR || startUpStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedDeviceBasicInformationClusterStartUpEvent 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BridgedDeviceBasicInformationClusterShutDownEvent",
                shutDownStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedDeviceBasicInformationClusterShutDownEvent");
                return nullptr;
            }

            jmethodID shutDownStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, shutDownStructClass, "<init>", "()V", &shutDownStructCtor);
            if (err != CHIP_NO_ERROR || shutDownStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedDeviceBasicInformationClusterShutDownEvent 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BridgedDeviceBasicInformationClusterLeaveEvent", leaveStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BridgedDeviceBasicInformationClusterLeaveEvent");
                return nullptr;
            }

            jmethodID leaveStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, leaveStructClass, "<init>", "()V", &leaveStructCtor);
            if (err != CHIP_NO_ERROR || leaveStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$BridgedDeviceBasicInformationClusterLeaveEvent 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";
            jboolean jnivalue_reachableNewValue              = static_cast<jboolean>(cppValue.reachableNewValue);
            chip::JniReferences::GetInstance().CreateBoxedObject<jboolean>(value_reachableNewValueClassName.c_str(),
                                                                           value_reachableNewValueCtorSignature.c_str(),
                                                                           jnivalue_reachableNewValue, value_reachableNewValue);

            jclass reachableChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BridgedDeviceBasicInformationClusterReachableChangedEvent",
                reachableChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$BridgedDeviceBasicInformationClusterReachableChangedEvent");
                return nullptr;
            }

            jmethodID reachableChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, reachableChangedStructClass, "<init>",
                                                                "(Ljava/lang/Boolean;)V", &reachableChangedStructCtor);
            if (err != CHIP_NO_ERROR || reachableChangedStructCtor == nullptr)
            {
                ChipLogError(
                    Zcl, "Could not find ChipEventStructs$BridgedDeviceBasicInformationClusterReachableChangedEvent 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";
            jint jnivalue_newPosition                  = static_cast<jint>(cppValue.newPosition);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_newPositionClassName.c_str(),
                                                                       value_newPositionCtorSignature.c_str(), jnivalue_newPosition,
                                                                       value_newPosition);

            jclass switchLatchedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterSwitchLatchedEvent", switchLatchedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterSwitchLatchedEvent");
                return nullptr;
            }

            jmethodID switchLatchedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, switchLatchedStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &switchLatchedStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_newPosition                  = static_cast<jint>(cppValue.newPosition);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_newPositionClassName.c_str(),
                                                                       value_newPositionCtorSignature.c_str(), jnivalue_newPosition,
                                                                       value_newPosition);

            jclass initialPressStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterInitialPressEvent", initialPressStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterInitialPressEvent");
                return nullptr;
            }

            jmethodID initialPressStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, initialPressStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &initialPressStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_newPosition                  = static_cast<jint>(cppValue.newPosition);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_newPositionClassName.c_str(),
                                                                       value_newPositionCtorSignature.c_str(), jnivalue_newPosition,
                                                                       value_newPosition);

            jclass longPressStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterLongPressEvent", longPressStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterLongPressEvent");
                return nullptr;
            }

            jmethodID longPressStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, longPressStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &longPressStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_previousPosition                  = static_cast<jint>(cppValue.previousPosition);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_previousPositionClassName.c_str(),
                                                                       value_previousPositionCtorSignature.c_str(),
                                                                       jnivalue_previousPosition, value_previousPosition);

            jclass shortReleaseStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterShortReleaseEvent", shortReleaseStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterShortReleaseEvent");
                return nullptr;
            }

            jmethodID shortReleaseStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, shortReleaseStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &shortReleaseStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_previousPosition                  = static_cast<jint>(cppValue.previousPosition);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_previousPositionClassName.c_str(),
                                                                       value_previousPositionCtorSignature.c_str(),
                                                                       jnivalue_previousPosition, value_previousPosition);

            jclass longReleaseStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterLongReleaseEvent", longReleaseStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterLongReleaseEvent");
                return nullptr;
            }

            jmethodID longReleaseStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, longReleaseStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &longReleaseStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_newPosition                  = static_cast<jint>(cppValue.newPosition);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_newPositionClassName.c_str(),
                                                                       value_newPositionCtorSignature.c_str(), jnivalue_newPosition,
                                                                       value_newPosition);

            jobject value_currentNumberOfPressesCounted;
            std::string value_currentNumberOfPressesCountedClassName     = "java/lang/Integer";
            std::string value_currentNumberOfPressesCountedCtorSignature = "(I)V";
            jint jnivalue_currentNumberOfPressesCounted = static_cast<jint>(cppValue.currentNumberOfPressesCounted);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_currentNumberOfPressesCountedClassName.c_str(), value_currentNumberOfPressesCountedCtorSignature.c_str(),
                jnivalue_currentNumberOfPressesCounted, value_currentNumberOfPressesCounted);

            jclass multiPressOngoingStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterMultiPressOngoingEvent", multiPressOngoingStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterMultiPressOngoingEvent");
                return nullptr;
            }

            jmethodID multiPressOngoingStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, multiPressOngoingStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                                &multiPressOngoingStructCtor);
            if (err != CHIP_NO_ERROR || 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_previousPosition;
            std::string value_previousPositionClassName     = "java/lang/Integer";
            std::string value_previousPositionCtorSignature = "(I)V";
            jint jnivalue_previousPosition                  = static_cast<jint>(cppValue.previousPosition);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_previousPositionClassName.c_str(),
                                                                       value_previousPositionCtorSignature.c_str(),
                                                                       jnivalue_previousPosition, value_previousPosition);

            jobject value_totalNumberOfPressesCounted;
            std::string value_totalNumberOfPressesCountedClassName     = "java/lang/Integer";
            std::string value_totalNumberOfPressesCountedCtorSignature = "(I)V";
            jint jnivalue_totalNumberOfPressesCounted                  = static_cast<jint>(cppValue.totalNumberOfPressesCounted);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_totalNumberOfPressesCountedClassName.c_str(), value_totalNumberOfPressesCountedCtorSignature.c_str(),
                jnivalue_totalNumberOfPressesCounted, value_totalNumberOfPressesCounted);

            jclass multiPressCompleteStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SwitchClusterMultiPressCompleteEvent", multiPressCompleteStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SwitchClusterMultiPressCompleteEvent");
                return nullptr;
            }

            jmethodID multiPressCompleteStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, multiPressCompleteStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                                &multiPressCompleteStructCtor);
            if (err != CHIP_NO_ERROR || multiPressCompleteStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SwitchClusterMultiPressCompleteEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(multiPressCompleteStructClass, multiPressCompleteStructCtor, value_previousPosition,
                                           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::ProxyConfiguration::Id: {
        using namespace app::Clusters::ProxyConfiguration;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ProxyDiscovery::Id: {
        using namespace app::Clusters::ProxyDiscovery;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ProxyValid::Id: {
        using namespace app::Clusters::ProxyValid;
        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";
            jboolean jnivalue_stateValue              = static_cast<jboolean>(cppValue.stateValue);
            chip::JniReferences::GetInstance().CreateBoxedObject<jboolean>(
                value_stateValueClassName.c_str(), value_stateValueCtorSignature.c_str(), jnivalue_stateValue, value_stateValue);

            jclass stateChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BooleanStateClusterStateChangeEvent", stateChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BooleanStateClusterStateChangeEvent");
                return nullptr;
            }

            jmethodID stateChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, stateChangeStructClass, "<init>", "(Ljava/lang/Boolean;)V",
                                                                &stateChangeStructCtor);
            if (err != CHIP_NO_ERROR || 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::IcdManagement::Id: {
        using namespace app::Clusters::IcdManagement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::Timer::Id: {
        using namespace app::Clusters::Timer;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::OvenCavityOperationalState::Id: {
        using namespace app::Clusters::OvenCavityOperationalState;
        switch (aPath.mEventId)
        {
        case Events::OperationalError::Id: {
            Events::OperationalError::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_errorState;
            jobject value_errorState_errorStateID;
            std::string value_errorState_errorStateIDClassName     = "java/lang/Integer";
            std::string value_errorState_errorStateIDCtorSignature = "(I)V";
            jint jnivalue_errorState_errorStateID                  = static_cast<jint>(cppValue.errorState.errorStateID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_errorState_errorStateIDClassName.c_str(), value_errorState_errorStateIDCtorSignature.c_str(),
                jnivalue_errorState_errorStateID, value_errorState_errorStateID);
            jobject value_errorState_errorStateLabel;
            if (!cppValue.errorState.errorStateLabel.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_errorState_errorStateLabel);
            }
            else
            {
                jobject value_errorState_errorStateLabelInsideOptional;
                LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(
                    cppValue.errorState.errorStateLabel.Value(), value_errorState_errorStateLabelInsideOptional));
                chip::JniReferences::GetInstance().CreateOptional(value_errorState_errorStateLabelInsideOptional,
                                                                  value_errorState_errorStateLabel);
            }
            jobject value_errorState_errorStateDetails;
            if (!cppValue.errorState.errorStateDetails.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_errorState_errorStateDetails);
            }
            else
            {
                jobject value_errorState_errorStateDetailsInsideOptional;
                LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(
                    cppValue.errorState.errorStateDetails.Value(), value_errorState_errorStateDetailsInsideOptional));
                chip::JniReferences::GetInstance().CreateOptional(value_errorState_errorStateDetailsInsideOptional,
                                                                  value_errorState_errorStateDetails);
            }

            jclass errorStateStructStructClass_0;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipStructs$OvenCavityOperationalStateClusterErrorStateStruct",
                errorStateStructStructClass_0);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipStructs$OvenCavityOperationalStateClusterErrorStateStruct");
                return nullptr;
            }

            jmethodID errorStateStructStructCtor_0;
            err = chip::JniReferences::GetInstance().FindMethod(env, errorStateStructStructClass_0, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &errorStateStructStructCtor_0);
            if (err != CHIP_NO_ERROR || errorStateStructStructCtor_0 == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipStructs$OvenCavityOperationalStateClusterErrorStateStruct constructor");
                return nullptr;
            }

            value_errorState =
                env->NewObject(errorStateStructStructClass_0, errorStateStructStructCtor_0, value_errorState_errorStateID,
                               value_errorState_errorStateLabel, value_errorState_errorStateDetails);

            jclass operationalErrorStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$OvenCavityOperationalStateClusterOperationalErrorEvent",
                operationalErrorStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$OvenCavityOperationalStateClusterOperationalErrorEvent");
                return nullptr;
            }

            jmethodID operationalErrorStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, operationalErrorStructClass, "<init>",
                "(Lchip/devicecontroller/ChipStructs$OvenCavityOperationalStateClusterErrorStateStruct;)V",
                &operationalErrorStructCtor);
            if (err != CHIP_NO_ERROR || operationalErrorStructCtor == nullptr)
            {
                ChipLogError(Zcl,
                             "Could not find ChipEventStructs$OvenCavityOperationalStateClusterOperationalErrorEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(operationalErrorStructClass, operationalErrorStructCtor, value_errorState);

            return value;
        }
        case Events::OperationCompletion::Id: {
            Events::OperationCompletion::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_completionErrorCode;
            std::string value_completionErrorCodeClassName     = "java/lang/Integer";
            std::string value_completionErrorCodeCtorSignature = "(I)V";
            jint jnivalue_completionErrorCode                  = static_cast<jint>(cppValue.completionErrorCode);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_completionErrorCodeClassName.c_str(),
                                                                       value_completionErrorCodeCtorSignature.c_str(),
                                                                       jnivalue_completionErrorCode, value_completionErrorCode);

            jobject value_totalOperationalTime;
            if (!cppValue.totalOperationalTime.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_totalOperationalTime);
            }
            else
            {
                jobject value_totalOperationalTimeInsideOptional;
                if (cppValue.totalOperationalTime.Value().IsNull())
                {
                    value_totalOperationalTimeInsideOptional = nullptr;
                }
                else
                {
                    std::string value_totalOperationalTimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_totalOperationalTimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_totalOperationalTimeInsideOptional =
                        static_cast<jlong>(cppValue.totalOperationalTime.Value().Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_totalOperationalTimeInsideOptionalClassName.c_str(),
                        value_totalOperationalTimeInsideOptionalCtorSignature.c_str(), jnivalue_totalOperationalTimeInsideOptional,
                        value_totalOperationalTimeInsideOptional);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_totalOperationalTimeInsideOptional,
                                                                  value_totalOperationalTime);
            }

            jobject value_pausedTime;
            if (!cppValue.pausedTime.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_pausedTime);
            }
            else
            {
                jobject value_pausedTimeInsideOptional;
                if (cppValue.pausedTime.Value().IsNull())
                {
                    value_pausedTimeInsideOptional = nullptr;
                }
                else
                {
                    std::string value_pausedTimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_pausedTimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_pausedTimeInsideOptional = static_cast<jlong>(cppValue.pausedTime.Value().Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_pausedTimeInsideOptionalClassName.c_str(), value_pausedTimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_pausedTimeInsideOptional, value_pausedTimeInsideOptional);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_pausedTimeInsideOptional, value_pausedTime);
            }

            jclass operationCompletionStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$OvenCavityOperationalStateClusterOperationCompletionEvent",
                operationCompletionStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$OvenCavityOperationalStateClusterOperationCompletionEvent");
                return nullptr;
            }

            jmethodID operationCompletionStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, operationCompletionStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &operationCompletionStructCtor);
            if (err != CHIP_NO_ERROR || operationCompletionStructCtor == nullptr)
            {
                ChipLogError(
                    Zcl, "Could not find ChipEventStructs$OvenCavityOperationalStateClusterOperationCompletionEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(operationCompletionStructClass, operationCompletionStructCtor, value_completionErrorCode,
                                           value_totalOperationalTime, value_pausedTime);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::OvenMode::Id: {
        using namespace app::Clusters::OvenMode;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::LaundryDryerControls::Id: {
        using namespace app::Clusters::LaundryDryerControls;
        switch (aPath.mEventId)
        {
        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::LaundryWasherMode::Id: {
        using namespace app::Clusters::LaundryWasherMode;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id: {
        using namespace app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::LaundryWasherControls::Id: {
        using namespace app::Clusters::LaundryWasherControls;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::RvcRunMode::Id: {
        using namespace app::Clusters::RvcRunMode;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::RvcCleanMode::Id: {
        using namespace app::Clusters::RvcCleanMode;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::TemperatureControl::Id: {
        using namespace app::Clusters::TemperatureControl;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::RefrigeratorAlarm::Id: {
        using namespace app::Clusters::RefrigeratorAlarm;
        switch (aPath.mEventId)
        {
        case Events::Notify::Id: {
            Events::Notify::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_active;
            std::string value_activeClassName     = "java/lang/Long";
            std::string value_activeCtorSignature = "(J)V";
            jlong jnivalue_active                 = static_cast<jlong>(cppValue.active.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_activeClassName.c_str(), value_activeCtorSignature.c_str(), jnivalue_active, value_active);

            jobject value_inactive;
            std::string value_inactiveClassName     = "java/lang/Long";
            std::string value_inactiveCtorSignature = "(J)V";
            jlong jnivalue_inactive                 = static_cast<jlong>(cppValue.inactive.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_inactiveClassName.c_str(), value_inactiveCtorSignature.c_str(), jnivalue_inactive, value_inactive);

            jobject value_state;
            std::string value_stateClassName     = "java/lang/Long";
            std::string value_stateCtorSignature = "(J)V";
            jlong jnivalue_state                 = static_cast<jlong>(cppValue.state.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_stateClassName.c_str(), value_stateCtorSignature.c_str(), jnivalue_state, value_state);

            jobject value_mask;
            std::string value_maskClassName     = "java/lang/Long";
            std::string value_maskCtorSignature = "(J)V";
            jlong jnivalue_mask                 = static_cast<jlong>(cppValue.mask.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_maskClassName.c_str(),
                                                                        value_maskCtorSignature.c_str(), jnivalue_mask, value_mask);

            jclass notifyStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$RefrigeratorAlarmClusterNotifyEvent", notifyStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$RefrigeratorAlarmClusterNotifyEvent");
                return nullptr;
            }

            jmethodID notifyStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, notifyStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Long;)V",
                &notifyStructCtor);
            if (err != CHIP_NO_ERROR || notifyStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$RefrigeratorAlarmClusterNotifyEvent constructor");
                return nullptr;
            }

            jobject value =
                env->NewObject(notifyStructClass, notifyStructCtor, value_active, value_inactive, value_state, value_mask);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::DishwasherMode::Id: {
        using namespace app::Clusters::DishwasherMode;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::AirQuality::Id: {
        using namespace app::Clusters::AirQuality;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::SmokeCoAlarm::Id: {
        using namespace app::Clusters::SmokeCoAlarm;
        switch (aPath.mEventId)
        {
        case Events::SmokeAlarm::Id: {
            Events::SmokeAlarm::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_alarmSeverityLevel;
            std::string value_alarmSeverityLevelClassName     = "java/lang/Integer";
            std::string value_alarmSeverityLevelCtorSignature = "(I)V";
            jint jnivalue_alarmSeverityLevel                  = static_cast<jint>(cppValue.alarmSeverityLevel);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_alarmSeverityLevelClassName.c_str(),
                                                                       value_alarmSeverityLevelCtorSignature.c_str(),
                                                                       jnivalue_alarmSeverityLevel, value_alarmSeverityLevel);

            jclass smokeAlarmStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterSmokeAlarmEvent", smokeAlarmStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterSmokeAlarmEvent");
                return nullptr;
            }

            jmethodID smokeAlarmStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, smokeAlarmStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &smokeAlarmStructCtor);
            if (err != CHIP_NO_ERROR || smokeAlarmStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterSmokeAlarmEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(smokeAlarmStructClass, smokeAlarmStructCtor, value_alarmSeverityLevel);

            return value;
        }
        case Events::COAlarm::Id: {
            Events::COAlarm::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_alarmSeverityLevel;
            std::string value_alarmSeverityLevelClassName     = "java/lang/Integer";
            std::string value_alarmSeverityLevelCtorSignature = "(I)V";
            jint jnivalue_alarmSeverityLevel                  = static_cast<jint>(cppValue.alarmSeverityLevel);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_alarmSeverityLevelClassName.c_str(),
                                                                       value_alarmSeverityLevelCtorSignature.c_str(),
                                                                       jnivalue_alarmSeverityLevel, value_alarmSeverityLevel);

            jclass COAlarmStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterCOAlarmEvent", COAlarmStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterCOAlarmEvent");
                return nullptr;
            }

            jmethodID COAlarmStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, COAlarmStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &COAlarmStructCtor);
            if (err != CHIP_NO_ERROR || COAlarmStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterCOAlarmEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(COAlarmStructClass, COAlarmStructCtor, value_alarmSeverityLevel);

            return value;
        }
        case Events::LowBattery::Id: {
            Events::LowBattery::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_alarmSeverityLevel;
            std::string value_alarmSeverityLevelClassName     = "java/lang/Integer";
            std::string value_alarmSeverityLevelCtorSignature = "(I)V";
            jint jnivalue_alarmSeverityLevel                  = static_cast<jint>(cppValue.alarmSeverityLevel);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_alarmSeverityLevelClassName.c_str(),
                                                                       value_alarmSeverityLevelCtorSignature.c_str(),
                                                                       jnivalue_alarmSeverityLevel, value_alarmSeverityLevel);

            jclass lowBatteryStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterLowBatteryEvent", lowBatteryStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterLowBatteryEvent");
                return nullptr;
            }

            jmethodID lowBatteryStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, lowBatteryStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &lowBatteryStructCtor);
            if (err != CHIP_NO_ERROR || lowBatteryStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterLowBatteryEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(lowBatteryStructClass, lowBatteryStructCtor, value_alarmSeverityLevel);

            return value;
        }
        case Events::HardwareFault::Id: {
            Events::HardwareFault::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass hardwareFaultStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterHardwareFaultEvent", hardwareFaultStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterHardwareFaultEvent");
                return nullptr;
            }

            jmethodID hardwareFaultStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, hardwareFaultStructClass, "<init>", "()V",
                                                                &hardwareFaultStructCtor);
            if (err != CHIP_NO_ERROR || hardwareFaultStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterHardwareFaultEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(hardwareFaultStructClass, hardwareFaultStructCtor);

            return value;
        }
        case Events::EndOfService::Id: {
            Events::EndOfService::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass endOfServiceStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterEndOfServiceEvent", endOfServiceStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterEndOfServiceEvent");
                return nullptr;
            }

            jmethodID endOfServiceStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, endOfServiceStructClass, "<init>", "()V",
                                                                &endOfServiceStructCtor);
            if (err != CHIP_NO_ERROR || endOfServiceStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterEndOfServiceEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(endOfServiceStructClass, endOfServiceStructCtor);

            return value;
        }
        case Events::SelfTestComplete::Id: {
            Events::SelfTestComplete::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass selfTestCompleteStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterSelfTestCompleteEvent",
                selfTestCompleteStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterSelfTestCompleteEvent");
                return nullptr;
            }

            jmethodID selfTestCompleteStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, selfTestCompleteStructClass, "<init>", "()V",
                                                                &selfTestCompleteStructCtor);
            if (err != CHIP_NO_ERROR || selfTestCompleteStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterSelfTestCompleteEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(selfTestCompleteStructClass, selfTestCompleteStructCtor);

            return value;
        }
        case Events::AlarmMuted::Id: {
            Events::AlarmMuted::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass alarmMutedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterAlarmMutedEvent", alarmMutedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterAlarmMutedEvent");
                return nullptr;
            }

            jmethodID alarmMutedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, alarmMutedStructClass, "<init>", "()V", &alarmMutedStructCtor);
            if (err != CHIP_NO_ERROR || alarmMutedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterAlarmMutedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(alarmMutedStructClass, alarmMutedStructCtor);

            return value;
        }
        case Events::MuteEnded::Id: {
            Events::MuteEnded::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass muteEndedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterMuteEndedEvent", muteEndedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterMuteEndedEvent");
                return nullptr;
            }

            jmethodID muteEndedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, muteEndedStructClass, "<init>", "()V", &muteEndedStructCtor);
            if (err != CHIP_NO_ERROR || muteEndedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterMuteEndedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(muteEndedStructClass, muteEndedStructCtor);

            return value;
        }
        case Events::InterconnectSmokeAlarm::Id: {
            Events::InterconnectSmokeAlarm::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_alarmSeverityLevel;
            std::string value_alarmSeverityLevelClassName     = "java/lang/Integer";
            std::string value_alarmSeverityLevelCtorSignature = "(I)V";
            jint jnivalue_alarmSeverityLevel                  = static_cast<jint>(cppValue.alarmSeverityLevel);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_alarmSeverityLevelClassName.c_str(),
                                                                       value_alarmSeverityLevelCtorSignature.c_str(),
                                                                       jnivalue_alarmSeverityLevel, value_alarmSeverityLevel);

            jclass interconnectSmokeAlarmStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterInterconnectSmokeAlarmEvent",
                interconnectSmokeAlarmStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterInterconnectSmokeAlarmEvent");
                return nullptr;
            }

            jmethodID interconnectSmokeAlarmStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, interconnectSmokeAlarmStructClass, "<init>",
                                                                "(Ljava/lang/Integer;)V", &interconnectSmokeAlarmStructCtor);
            if (err != CHIP_NO_ERROR || interconnectSmokeAlarmStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterInterconnectSmokeAlarmEvent constructor");
                return nullptr;
            }

            jobject value =
                env->NewObject(interconnectSmokeAlarmStructClass, interconnectSmokeAlarmStructCtor, value_alarmSeverityLevel);

            return value;
        }
        case Events::InterconnectCOAlarm::Id: {
            Events::InterconnectCOAlarm::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_alarmSeverityLevel;
            std::string value_alarmSeverityLevelClassName     = "java/lang/Integer";
            std::string value_alarmSeverityLevelCtorSignature = "(I)V";
            jint jnivalue_alarmSeverityLevel                  = static_cast<jint>(cppValue.alarmSeverityLevel);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_alarmSeverityLevelClassName.c_str(),
                                                                       value_alarmSeverityLevelCtorSignature.c_str(),
                                                                       jnivalue_alarmSeverityLevel, value_alarmSeverityLevel);

            jclass interconnectCOAlarmStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterInterconnectCOAlarmEvent",
                interconnectCOAlarmStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterInterconnectCOAlarmEvent");
                return nullptr;
            }

            jmethodID interconnectCOAlarmStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, interconnectCOAlarmStructClass, "<init>",
                                                                "(Ljava/lang/Integer;)V", &interconnectCOAlarmStructCtor);
            if (err != CHIP_NO_ERROR || interconnectCOAlarmStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterInterconnectCOAlarmEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(interconnectCOAlarmStructClass, interconnectCOAlarmStructCtor, value_alarmSeverityLevel);

            return value;
        }
        case Events::AllClear::Id: {
            Events::AllClear::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass allClearStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterAllClearEvent", allClearStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterAllClearEvent");
                return nullptr;
            }

            jmethodID allClearStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, allClearStructClass, "<init>", "()V", &allClearStructCtor);
            if (err != CHIP_NO_ERROR || allClearStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterAllClearEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(allClearStructClass, allClearStructCtor);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::DishwasherAlarm::Id: {
        using namespace app::Clusters::DishwasherAlarm;
        switch (aPath.mEventId)
        {
        case Events::Notify::Id: {
            Events::Notify::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_active;
            std::string value_activeClassName     = "java/lang/Long";
            std::string value_activeCtorSignature = "(J)V";
            jlong jnivalue_active                 = static_cast<jlong>(cppValue.active.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_activeClassName.c_str(), value_activeCtorSignature.c_str(), jnivalue_active, value_active);

            jobject value_inactive;
            std::string value_inactiveClassName     = "java/lang/Long";
            std::string value_inactiveCtorSignature = "(J)V";
            jlong jnivalue_inactive                 = static_cast<jlong>(cppValue.inactive.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_inactiveClassName.c_str(), value_inactiveCtorSignature.c_str(), jnivalue_inactive, value_inactive);

            jobject value_state;
            std::string value_stateClassName     = "java/lang/Long";
            std::string value_stateCtorSignature = "(J)V";
            jlong jnivalue_state                 = static_cast<jlong>(cppValue.state.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_stateClassName.c_str(), value_stateCtorSignature.c_str(), jnivalue_state, value_state);

            jobject value_mask;
            std::string value_maskClassName     = "java/lang/Long";
            std::string value_maskCtorSignature = "(J)V";
            jlong jnivalue_mask                 = static_cast<jlong>(cppValue.mask.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_maskClassName.c_str(),
                                                                        value_maskCtorSignature.c_str(), jnivalue_mask, value_mask);

            jclass notifyStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DishwasherAlarmClusterNotifyEvent", notifyStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DishwasherAlarmClusterNotifyEvent");
                return nullptr;
            }

            jmethodID notifyStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, notifyStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Long;)V",
                &notifyStructCtor);
            if (err != CHIP_NO_ERROR || notifyStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$DishwasherAlarmClusterNotifyEvent constructor");
                return nullptr;
            }

            jobject value =
                env->NewObject(notifyStructClass, notifyStructCtor, value_active, value_inactive, value_state, value_mask);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::MicrowaveOvenMode::Id: {
        using namespace app::Clusters::MicrowaveOvenMode;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::MicrowaveOvenControl::Id: {
        using namespace app::Clusters::MicrowaveOvenControl;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::OperationalState::Id: {
        using namespace app::Clusters::OperationalState;
        switch (aPath.mEventId)
        {
        case Events::OperationalError::Id: {
            Events::OperationalError::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_errorState;
            jobject value_errorState_errorStateID;
            std::string value_errorState_errorStateIDClassName     = "java/lang/Integer";
            std::string value_errorState_errorStateIDCtorSignature = "(I)V";
            jint jnivalue_errorState_errorStateID                  = static_cast<jint>(cppValue.errorState.errorStateID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_errorState_errorStateIDClassName.c_str(), value_errorState_errorStateIDCtorSignature.c_str(),
                jnivalue_errorState_errorStateID, value_errorState_errorStateID);
            jobject value_errorState_errorStateLabel;
            if (!cppValue.errorState.errorStateLabel.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_errorState_errorStateLabel);
            }
            else
            {
                jobject value_errorState_errorStateLabelInsideOptional;
                LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(
                    cppValue.errorState.errorStateLabel.Value(), value_errorState_errorStateLabelInsideOptional));
                chip::JniReferences::GetInstance().CreateOptional(value_errorState_errorStateLabelInsideOptional,
                                                                  value_errorState_errorStateLabel);
            }
            jobject value_errorState_errorStateDetails;
            if (!cppValue.errorState.errorStateDetails.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_errorState_errorStateDetails);
            }
            else
            {
                jobject value_errorState_errorStateDetailsInsideOptional;
                LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(
                    cppValue.errorState.errorStateDetails.Value(), value_errorState_errorStateDetailsInsideOptional));
                chip::JniReferences::GetInstance().CreateOptional(value_errorState_errorStateDetailsInsideOptional,
                                                                  value_errorState_errorStateDetails);
            }

            jclass errorStateStructStructClass_0;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipStructs$OperationalStateClusterErrorStateStruct", errorStateStructStructClass_0);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipStructs$OperationalStateClusterErrorStateStruct");
                return nullptr;
            }

            jmethodID errorStateStructStructCtor_0;
            err = chip::JniReferences::GetInstance().FindMethod(env, errorStateStructStructClass_0, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &errorStateStructStructCtor_0);
            if (err != CHIP_NO_ERROR || errorStateStructStructCtor_0 == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipStructs$OperationalStateClusterErrorStateStruct constructor");
                return nullptr;
            }

            value_errorState =
                env->NewObject(errorStateStructStructClass_0, errorStateStructStructCtor_0, value_errorState_errorStateID,
                               value_errorState_errorStateLabel, value_errorState_errorStateDetails);

            jclass operationalErrorStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$OperationalStateClusterOperationalErrorEvent",
                operationalErrorStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$OperationalStateClusterOperationalErrorEvent");
                return nullptr;
            }

            jmethodID operationalErrorStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, operationalErrorStructClass, "<init>",
                "(Lchip/devicecontroller/ChipStructs$OperationalStateClusterErrorStateStruct;)V", &operationalErrorStructCtor);
            if (err != CHIP_NO_ERROR || operationalErrorStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$OperationalStateClusterOperationalErrorEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(operationalErrorStructClass, operationalErrorStructCtor, value_errorState);

            return value;
        }
        case Events::OperationCompletion::Id: {
            Events::OperationCompletion::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_completionErrorCode;
            std::string value_completionErrorCodeClassName     = "java/lang/Integer";
            std::string value_completionErrorCodeCtorSignature = "(I)V";
            jint jnivalue_completionErrorCode                  = static_cast<jint>(cppValue.completionErrorCode);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_completionErrorCodeClassName.c_str(),
                                                                       value_completionErrorCodeCtorSignature.c_str(),
                                                                       jnivalue_completionErrorCode, value_completionErrorCode);

            jobject value_totalOperationalTime;
            if (!cppValue.totalOperationalTime.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_totalOperationalTime);
            }
            else
            {
                jobject value_totalOperationalTimeInsideOptional;
                if (cppValue.totalOperationalTime.Value().IsNull())
                {
                    value_totalOperationalTimeInsideOptional = nullptr;
                }
                else
                {
                    std::string value_totalOperationalTimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_totalOperationalTimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_totalOperationalTimeInsideOptional =
                        static_cast<jlong>(cppValue.totalOperationalTime.Value().Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_totalOperationalTimeInsideOptionalClassName.c_str(),
                        value_totalOperationalTimeInsideOptionalCtorSignature.c_str(), jnivalue_totalOperationalTimeInsideOptional,
                        value_totalOperationalTimeInsideOptional);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_totalOperationalTimeInsideOptional,
                                                                  value_totalOperationalTime);
            }

            jobject value_pausedTime;
            if (!cppValue.pausedTime.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_pausedTime);
            }
            else
            {
                jobject value_pausedTimeInsideOptional;
                if (cppValue.pausedTime.Value().IsNull())
                {
                    value_pausedTimeInsideOptional = nullptr;
                }
                else
                {
                    std::string value_pausedTimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_pausedTimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_pausedTimeInsideOptional = static_cast<jlong>(cppValue.pausedTime.Value().Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_pausedTimeInsideOptionalClassName.c_str(), value_pausedTimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_pausedTimeInsideOptional, value_pausedTimeInsideOptional);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_pausedTimeInsideOptional, value_pausedTime);
            }

            jclass operationCompletionStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$OperationalStateClusterOperationCompletionEvent",
                operationCompletionStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$OperationalStateClusterOperationCompletionEvent");
                return nullptr;
            }

            jmethodID operationCompletionStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, operationCompletionStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &operationCompletionStructCtor);
            if (err != CHIP_NO_ERROR || operationCompletionStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$OperationalStateClusterOperationCompletionEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(operationCompletionStructClass, operationCompletionStructCtor, value_completionErrorCode,
                                           value_totalOperationalTime, value_pausedTime);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::RvcOperationalState::Id: {
        using namespace app::Clusters::RvcOperationalState;
        switch (aPath.mEventId)
        {
        case Events::OperationalError::Id: {
            Events::OperationalError::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_errorState;
            jobject value_errorState_errorStateID;
            std::string value_errorState_errorStateIDClassName     = "java/lang/Integer";
            std::string value_errorState_errorStateIDCtorSignature = "(I)V";
            jint jnivalue_errorState_errorStateID                  = static_cast<jint>(cppValue.errorState.errorStateID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_errorState_errorStateIDClassName.c_str(), value_errorState_errorStateIDCtorSignature.c_str(),
                jnivalue_errorState_errorStateID, value_errorState_errorStateID);
            jobject value_errorState_errorStateLabel;
            if (!cppValue.errorState.errorStateLabel.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_errorState_errorStateLabel);
            }
            else
            {
                jobject value_errorState_errorStateLabelInsideOptional;
                LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(
                    cppValue.errorState.errorStateLabel.Value(), value_errorState_errorStateLabelInsideOptional));
                chip::JniReferences::GetInstance().CreateOptional(value_errorState_errorStateLabelInsideOptional,
                                                                  value_errorState_errorStateLabel);
            }
            jobject value_errorState_errorStateDetails;
            if (!cppValue.errorState.errorStateDetails.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_errorState_errorStateDetails);
            }
            else
            {
                jobject value_errorState_errorStateDetailsInsideOptional;
                LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(
                    cppValue.errorState.errorStateDetails.Value(), value_errorState_errorStateDetailsInsideOptional));
                chip::JniReferences::GetInstance().CreateOptional(value_errorState_errorStateDetailsInsideOptional,
                                                                  value_errorState_errorStateDetails);
            }

            jclass errorStateStructStructClass_0;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipStructs$RvcOperationalStateClusterErrorStateStruct", errorStateStructStructClass_0);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipStructs$RvcOperationalStateClusterErrorStateStruct");
                return nullptr;
            }

            jmethodID errorStateStructStructCtor_0;
            err = chip::JniReferences::GetInstance().FindMethod(env, errorStateStructStructClass_0, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &errorStateStructStructCtor_0);
            if (err != CHIP_NO_ERROR || errorStateStructStructCtor_0 == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipStructs$RvcOperationalStateClusterErrorStateStruct constructor");
                return nullptr;
            }

            value_errorState =
                env->NewObject(errorStateStructStructClass_0, errorStateStructStructCtor_0, value_errorState_errorStateID,
                               value_errorState_errorStateLabel, value_errorState_errorStateDetails);

            jclass operationalErrorStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$RvcOperationalStateClusterOperationalErrorEvent",
                operationalErrorStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$RvcOperationalStateClusterOperationalErrorEvent");
                return nullptr;
            }

            jmethodID operationalErrorStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, operationalErrorStructClass, "<init>",
                "(Lchip/devicecontroller/ChipStructs$RvcOperationalStateClusterErrorStateStruct;)V", &operationalErrorStructCtor);
            if (err != CHIP_NO_ERROR || operationalErrorStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$RvcOperationalStateClusterOperationalErrorEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(operationalErrorStructClass, operationalErrorStructCtor, value_errorState);

            return value;
        }
        case Events::OperationCompletion::Id: {
            Events::OperationCompletion::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_completionErrorCode;
            std::string value_completionErrorCodeClassName     = "java/lang/Integer";
            std::string value_completionErrorCodeCtorSignature = "(I)V";
            jint jnivalue_completionErrorCode                  = static_cast<jint>(cppValue.completionErrorCode);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_completionErrorCodeClassName.c_str(),
                                                                       value_completionErrorCodeCtorSignature.c_str(),
                                                                       jnivalue_completionErrorCode, value_completionErrorCode);

            jobject value_totalOperationalTime;
            if (!cppValue.totalOperationalTime.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_totalOperationalTime);
            }
            else
            {
                jobject value_totalOperationalTimeInsideOptional;
                if (cppValue.totalOperationalTime.Value().IsNull())
                {
                    value_totalOperationalTimeInsideOptional = nullptr;
                }
                else
                {
                    std::string value_totalOperationalTimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_totalOperationalTimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_totalOperationalTimeInsideOptional =
                        static_cast<jlong>(cppValue.totalOperationalTime.Value().Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_totalOperationalTimeInsideOptionalClassName.c_str(),
                        value_totalOperationalTimeInsideOptionalCtorSignature.c_str(), jnivalue_totalOperationalTimeInsideOptional,
                        value_totalOperationalTimeInsideOptional);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_totalOperationalTimeInsideOptional,
                                                                  value_totalOperationalTime);
            }

            jobject value_pausedTime;
            if (!cppValue.pausedTime.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_pausedTime);
            }
            else
            {
                jobject value_pausedTimeInsideOptional;
                if (cppValue.pausedTime.Value().IsNull())
                {
                    value_pausedTimeInsideOptional = nullptr;
                }
                else
                {
                    std::string value_pausedTimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_pausedTimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_pausedTimeInsideOptional = static_cast<jlong>(cppValue.pausedTime.Value().Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_pausedTimeInsideOptionalClassName.c_str(), value_pausedTimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_pausedTimeInsideOptional, value_pausedTimeInsideOptional);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_pausedTimeInsideOptional, value_pausedTime);
            }

            jclass operationCompletionStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$RvcOperationalStateClusterOperationCompletionEvent",
                operationCompletionStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$RvcOperationalStateClusterOperationCompletionEvent");
                return nullptr;
            }

            jmethodID operationCompletionStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, operationCompletionStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &operationCompletionStructCtor);
            if (err != CHIP_NO_ERROR || operationCompletionStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$RvcOperationalStateClusterOperationCompletionEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(operationCompletionStructClass, operationCompletionStructCtor, value_completionErrorCode,
                                           value_totalOperationalTime, value_pausedTime);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ScenesManagement::Id: {
        using namespace app::Clusters::ScenesManagement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::HepaFilterMonitoring::Id: {
        using namespace app::Clusters::HepaFilterMonitoring;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ActivatedCarbonFilterMonitoring::Id: {
        using namespace app::Clusters::ActivatedCarbonFilterMonitoring;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::BooleanStateConfiguration::Id: {
        using namespace app::Clusters::BooleanStateConfiguration;
        switch (aPath.mEventId)
        {
        case Events::AlarmsStateChanged::Id: {
            Events::AlarmsStateChanged::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_alarmsActive;
            std::string value_alarmsActiveClassName     = "java/lang/Integer";
            std::string value_alarmsActiveCtorSignature = "(I)V";
            jint jnivalue_alarmsActive                  = static_cast<jint>(cppValue.alarmsActive.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_alarmsActiveClassName.c_str(),
                                                                       value_alarmsActiveCtorSignature.c_str(),
                                                                       jnivalue_alarmsActive, value_alarmsActive);

            jobject value_alarmsSuppressed;
            if (!cppValue.alarmsSuppressed.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_alarmsSuppressed);
            }
            else
            {
                jobject value_alarmsSuppressedInsideOptional;
                std::string value_alarmsSuppressedInsideOptionalClassName     = "java/lang/Integer";
                std::string value_alarmsSuppressedInsideOptionalCtorSignature = "(I)V";
                jint jnivalue_alarmsSuppressedInsideOptional = static_cast<jint>(cppValue.alarmsSuppressed.Value().Raw());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_alarmsSuppressedInsideOptionalClassName.c_str(),
                    value_alarmsSuppressedInsideOptionalCtorSignature.c_str(), jnivalue_alarmsSuppressedInsideOptional,
                    value_alarmsSuppressedInsideOptional);
                chip::JniReferences::GetInstance().CreateOptional(value_alarmsSuppressedInsideOptional, value_alarmsSuppressed);
            }

            jclass alarmsStateChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BooleanStateConfigurationClusterAlarmsStateChangedEvent",
                alarmsStateChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BooleanStateConfigurationClusterAlarmsStateChangedEvent");
                return nullptr;
            }

            jmethodID alarmsStateChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, alarmsStateChangedStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/util/Optional;)V",
                                                                &alarmsStateChangedStructCtor);
            if (err != CHIP_NO_ERROR || alarmsStateChangedStructCtor == nullptr)
            {
                ChipLogError(Zcl,
                             "Could not find ChipEventStructs$BooleanStateConfigurationClusterAlarmsStateChangedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(alarmsStateChangedStructClass, alarmsStateChangedStructCtor, value_alarmsActive,
                                           value_alarmsSuppressed);

            return value;
        }
        case Events::SensorFault::Id: {
            Events::SensorFault::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_sensorFault;
            std::string value_sensorFaultClassName     = "java/lang/Integer";
            std::string value_sensorFaultCtorSignature = "(I)V";
            jint jnivalue_sensorFault                  = static_cast<jint>(cppValue.sensorFault.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_sensorFaultClassName.c_str(),
                                                                       value_sensorFaultCtorSignature.c_str(), jnivalue_sensorFault,
                                                                       value_sensorFault);

            jclass sensorFaultStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$BooleanStateConfigurationClusterSensorFaultEvent",
                sensorFaultStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$BooleanStateConfigurationClusterSensorFaultEvent");
                return nullptr;
            }

            jmethodID sensorFaultStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, sensorFaultStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &sensorFaultStructCtor);
            if (err != CHIP_NO_ERROR || sensorFaultStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$BooleanStateConfigurationClusterSensorFaultEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(sensorFaultStructClass, sensorFaultStructCtor, value_sensorFault);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ValveConfigurationAndControl::Id: {
        using namespace app::Clusters::ValveConfigurationAndControl;
        switch (aPath.mEventId)
        {
        case Events::ValveStateChanged::Id: {
            Events::ValveStateChanged::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_valveState;
            std::string value_valveStateClassName     = "java/lang/Integer";
            std::string value_valveStateCtorSignature = "(I)V";
            jint jnivalue_valveState                  = static_cast<jint>(cppValue.valveState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_valveStateClassName.c_str(), value_valveStateCtorSignature.c_str(), jnivalue_valveState, value_valveState);

            jobject value_valveLevel;
            if (!cppValue.valveLevel.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_valveLevel);
            }
            else
            {
                jobject value_valveLevelInsideOptional;
                std::string value_valveLevelInsideOptionalClassName     = "java/lang/Integer";
                std::string value_valveLevelInsideOptionalCtorSignature = "(I)V";
                jint jnivalue_valveLevelInsideOptional                  = static_cast<jint>(cppValue.valveLevel.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_valveLevelInsideOptionalClassName.c_str(), value_valveLevelInsideOptionalCtorSignature.c_str(),
                    jnivalue_valveLevelInsideOptional, value_valveLevelInsideOptional);
                chip::JniReferences::GetInstance().CreateOptional(value_valveLevelInsideOptional, value_valveLevel);
            }

            jclass valveStateChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ValveConfigurationAndControlClusterValveStateChangedEvent",
                valveStateChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$ValveConfigurationAndControlClusterValveStateChangedEvent");
                return nullptr;
            }

            jmethodID valveStateChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, valveStateChangedStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/util/Optional;)V",
                                                                &valveStateChangedStructCtor);
            if (err != CHIP_NO_ERROR || valveStateChangedStructCtor == nullptr)
            {
                ChipLogError(
                    Zcl, "Could not find ChipEventStructs$ValveConfigurationAndControlClusterValveStateChangedEvent constructor");
                return nullptr;
            }

            jobject value =
                env->NewObject(valveStateChangedStructClass, valveStateChangedStructCtor, value_valveState, value_valveLevel);

            return value;
        }
        case Events::ValveFault::Id: {
            Events::ValveFault::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_valveFault;
            std::string value_valveFaultClassName     = "java/lang/Integer";
            std::string value_valveFaultCtorSignature = "(I)V";
            jint jnivalue_valveFault                  = static_cast<jint>(cppValue.valveFault.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_valveFaultClassName.c_str(), value_valveFaultCtorSignature.c_str(), jnivalue_valveFault, value_valveFault);

            jclass valveFaultStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ValveConfigurationAndControlClusterValveFaultEvent",
                valveFaultStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$ValveConfigurationAndControlClusterValveFaultEvent");
                return nullptr;
            }

            jmethodID valveFaultStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, valveFaultStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &valveFaultStructCtor);
            if (err != CHIP_NO_ERROR || valveFaultStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$ValveConfigurationAndControlClusterValveFaultEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(valveFaultStructClass, valveFaultStructCtor, value_valveFault);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ElectricalPowerMeasurement::Id: {
        using namespace app::Clusters::ElectricalPowerMeasurement;
        switch (aPath.mEventId)
        {
        case Events::MeasurementPeriodRanges::Id: {
            Events::MeasurementPeriodRanges::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_ranges;
            chip::JniReferences::GetInstance().CreateArrayList(value_ranges);

            auto iter_value_ranges_0 = cppValue.ranges.begin();
            while (iter_value_ranges_0.Next())
            {
                auto & entry_0 = iter_value_ranges_0.GetValue();
                jobject newElement_0;
                jobject newElement_0_measurementType;
                std::string newElement_0_measurementTypeClassName     = "java/lang/Integer";
                std::string newElement_0_measurementTypeCtorSignature = "(I)V";
                jint jninewElement_0_measurementType                  = static_cast<jint>(entry_0.measurementType);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0_measurementTypeClassName.c_str(), newElement_0_measurementTypeCtorSignature.c_str(),
                    jninewElement_0_measurementType, newElement_0_measurementType);
                jobject newElement_0_min;
                std::string newElement_0_minClassName     = "java/lang/Long";
                std::string newElement_0_minCtorSignature = "(J)V";
                jlong jninewElement_0_min                 = static_cast<jlong>(entry_0.min);
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(newElement_0_minClassName.c_str(),
                                                                            newElement_0_minCtorSignature.c_str(),
                                                                            jninewElement_0_min, newElement_0_min);
                jobject newElement_0_max;
                std::string newElement_0_maxClassName     = "java/lang/Long";
                std::string newElement_0_maxCtorSignature = "(J)V";
                jlong jninewElement_0_max                 = static_cast<jlong>(entry_0.max);
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(newElement_0_maxClassName.c_str(),
                                                                            newElement_0_maxCtorSignature.c_str(),
                                                                            jninewElement_0_max, newElement_0_max);
                jobject newElement_0_startTimestamp;
                if (!entry_0.startTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_startTimestamp);
                }
                else
                {
                    jobject newElement_0_startTimestampInsideOptional;
                    std::string newElement_0_startTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string newElement_0_startTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jninewElement_0_startTimestampInsideOptional = static_cast<jlong>(entry_0.startTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        newElement_0_startTimestampInsideOptionalClassName.c_str(),
                        newElement_0_startTimestampInsideOptionalCtorSignature.c_str(),
                        jninewElement_0_startTimestampInsideOptional, newElement_0_startTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(newElement_0_startTimestampInsideOptional,
                                                                      newElement_0_startTimestamp);
                }
                jobject newElement_0_endTimestamp;
                if (!entry_0.endTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_endTimestamp);
                }
                else
                {
                    jobject newElement_0_endTimestampInsideOptional;
                    std::string newElement_0_endTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string newElement_0_endTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jninewElement_0_endTimestampInsideOptional = static_cast<jlong>(entry_0.endTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        newElement_0_endTimestampInsideOptionalClassName.c_str(),
                        newElement_0_endTimestampInsideOptionalCtorSignature.c_str(), jninewElement_0_endTimestampInsideOptional,
                        newElement_0_endTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(newElement_0_endTimestampInsideOptional,
                                                                      newElement_0_endTimestamp);
                }
                jobject newElement_0_minTimestamp;
                if (!entry_0.minTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_minTimestamp);
                }
                else
                {
                    jobject newElement_0_minTimestampInsideOptional;
                    std::string newElement_0_minTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string newElement_0_minTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jninewElement_0_minTimestampInsideOptional = static_cast<jlong>(entry_0.minTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        newElement_0_minTimestampInsideOptionalClassName.c_str(),
                        newElement_0_minTimestampInsideOptionalCtorSignature.c_str(), jninewElement_0_minTimestampInsideOptional,
                        newElement_0_minTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(newElement_0_minTimestampInsideOptional,
                                                                      newElement_0_minTimestamp);
                }
                jobject newElement_0_maxTimestamp;
                if (!entry_0.maxTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_maxTimestamp);
                }
                else
                {
                    jobject newElement_0_maxTimestampInsideOptional;
                    std::string newElement_0_maxTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string newElement_0_maxTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jninewElement_0_maxTimestampInsideOptional = static_cast<jlong>(entry_0.maxTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        newElement_0_maxTimestampInsideOptionalClassName.c_str(),
                        newElement_0_maxTimestampInsideOptionalCtorSignature.c_str(), jninewElement_0_maxTimestampInsideOptional,
                        newElement_0_maxTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(newElement_0_maxTimestampInsideOptional,
                                                                      newElement_0_maxTimestamp);
                }
                jobject newElement_0_startSystime;
                if (!entry_0.startSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_startSystime);
                }
                else
                {
                    jobject newElement_0_startSystimeInsideOptional;
                    std::string newElement_0_startSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string newElement_0_startSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jninewElement_0_startSystimeInsideOptional = static_cast<jlong>(entry_0.startSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        newElement_0_startSystimeInsideOptionalClassName.c_str(),
                        newElement_0_startSystimeInsideOptionalCtorSignature.c_str(), jninewElement_0_startSystimeInsideOptional,
                        newElement_0_startSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(newElement_0_startSystimeInsideOptional,
                                                                      newElement_0_startSystime);
                }
                jobject newElement_0_endSystime;
                if (!entry_0.endSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_endSystime);
                }
                else
                {
                    jobject newElement_0_endSystimeInsideOptional;
                    std::string newElement_0_endSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string newElement_0_endSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jninewElement_0_endSystimeInsideOptional                 = static_cast<jlong>(entry_0.endSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        newElement_0_endSystimeInsideOptionalClassName.c_str(),
                        newElement_0_endSystimeInsideOptionalCtorSignature.c_str(), jninewElement_0_endSystimeInsideOptional,
                        newElement_0_endSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(newElement_0_endSystimeInsideOptional,
                                                                      newElement_0_endSystime);
                }
                jobject newElement_0_minSystime;
                if (!entry_0.minSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_minSystime);
                }
                else
                {
                    jobject newElement_0_minSystimeInsideOptional;
                    std::string newElement_0_minSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string newElement_0_minSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jninewElement_0_minSystimeInsideOptional                 = static_cast<jlong>(entry_0.minSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        newElement_0_minSystimeInsideOptionalClassName.c_str(),
                        newElement_0_minSystimeInsideOptionalCtorSignature.c_str(), jninewElement_0_minSystimeInsideOptional,
                        newElement_0_minSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(newElement_0_minSystimeInsideOptional,
                                                                      newElement_0_minSystime);
                }
                jobject newElement_0_maxSystime;
                if (!entry_0.maxSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_maxSystime);
                }
                else
                {
                    jobject newElement_0_maxSystimeInsideOptional;
                    std::string newElement_0_maxSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string newElement_0_maxSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jninewElement_0_maxSystimeInsideOptional                 = static_cast<jlong>(entry_0.maxSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        newElement_0_maxSystimeInsideOptionalClassName.c_str(),
                        newElement_0_maxSystimeInsideOptionalCtorSignature.c_str(), jninewElement_0_maxSystimeInsideOptional,
                        newElement_0_maxSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(newElement_0_maxSystimeInsideOptional,
                                                                      newElement_0_maxSystime);
                }

                jclass measurementRangeStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$ElectricalPowerMeasurementClusterMeasurementRangeStruct",
                    measurementRangeStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$ElectricalPowerMeasurementClusterMeasurementRangeStruct");
                    return nullptr;
                }

                jmethodID measurementRangeStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(
                    env, measurementRangeStructStructClass_1, "<init>",
                    "(Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/"
                    "Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/"
                    "Optional;)V",
                    &measurementRangeStructStructCtor_1);
                if (err != CHIP_NO_ERROR || measurementRangeStructStructCtor_1 == nullptr)
                {
                    ChipLogError(Zcl,
                                 "Could not find ChipStructs$ElectricalPowerMeasurementClusterMeasurementRangeStruct constructor");
                    return nullptr;
                }

                newElement_0 = env->NewObject(measurementRangeStructStructClass_1, measurementRangeStructStructCtor_1,
                                              newElement_0_measurementType, newElement_0_min, newElement_0_max,
                                              newElement_0_startTimestamp, newElement_0_endTimestamp, newElement_0_minTimestamp,
                                              newElement_0_maxTimestamp, newElement_0_startSystime, newElement_0_endSystime,
                                              newElement_0_minSystime, newElement_0_maxSystime);
                chip::JniReferences::GetInstance().AddToList(value_ranges, newElement_0);
            }

            jclass measurementPeriodRangesStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ElectricalPowerMeasurementClusterMeasurementPeriodRangesEvent",
                measurementPeriodRangesStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$ElectricalPowerMeasurementClusterMeasurementPeriodRangesEvent");
                return nullptr;
            }

            jmethodID measurementPeriodRangesStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, measurementPeriodRangesStructClass, "<init>",
                                                                "(Ljava/util/ArrayList;)V", &measurementPeriodRangesStructCtor);
            if (err != CHIP_NO_ERROR || measurementPeriodRangesStructCtor == nullptr)
            {
                ChipLogError(
                    Zcl,
                    "Could not find ChipEventStructs$ElectricalPowerMeasurementClusterMeasurementPeriodRangesEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(measurementPeriodRangesStructClass, measurementPeriodRangesStructCtor, value_ranges);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ElectricalEnergyMeasurement::Id: {
        using namespace app::Clusters::ElectricalEnergyMeasurement;
        switch (aPath.mEventId)
        {
        case Events::CumulativeEnergyMeasured::Id: {
            Events::CumulativeEnergyMeasured::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_energyImported;
            if (!cppValue.energyImported.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImported);
            }
            else
            {
                jobject value_energyImportedInsideOptional;
                jobject value_energyImportedInsideOptional_energy;
                std::string value_energyImportedInsideOptional_energyClassName     = "java/lang/Long";
                std::string value_energyImportedInsideOptional_energyCtorSignature = "(J)V";
                jlong jnivalue_energyImportedInsideOptional_energy = static_cast<jlong>(cppValue.energyImported.Value().energy);
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                    value_energyImportedInsideOptional_energyClassName.c_str(),
                    value_energyImportedInsideOptional_energyCtorSignature.c_str(), jnivalue_energyImportedInsideOptional_energy,
                    value_energyImportedInsideOptional_energy);
                jobject value_energyImportedInsideOptional_startTimestamp;
                if (!cppValue.energyImported.Value().startTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImportedInsideOptional_startTimestamp);
                }
                else
                {
                    jobject value_energyImportedInsideOptional_startTimestampInsideOptional;
                    std::string value_energyImportedInsideOptional_startTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyImportedInsideOptional_startTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyImportedInsideOptional_startTimestampInsideOptional =
                        static_cast<jlong>(cppValue.energyImported.Value().startTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyImportedInsideOptional_startTimestampInsideOptionalClassName.c_str(),
                        value_energyImportedInsideOptional_startTimestampInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyImportedInsideOptional_startTimestampInsideOptional,
                        value_energyImportedInsideOptional_startTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(
                        value_energyImportedInsideOptional_startTimestampInsideOptional,
                        value_energyImportedInsideOptional_startTimestamp);
                }
                jobject value_energyImportedInsideOptional_endTimestamp;
                if (!cppValue.energyImported.Value().endTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImportedInsideOptional_endTimestamp);
                }
                else
                {
                    jobject value_energyImportedInsideOptional_endTimestampInsideOptional;
                    std::string value_energyImportedInsideOptional_endTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyImportedInsideOptional_endTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyImportedInsideOptional_endTimestampInsideOptional =
                        static_cast<jlong>(cppValue.energyImported.Value().endTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyImportedInsideOptional_endTimestampInsideOptionalClassName.c_str(),
                        value_energyImportedInsideOptional_endTimestampInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyImportedInsideOptional_endTimestampInsideOptional,
                        value_energyImportedInsideOptional_endTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyImportedInsideOptional_endTimestampInsideOptional,
                                                                      value_energyImportedInsideOptional_endTimestamp);
                }
                jobject value_energyImportedInsideOptional_startSystime;
                if (!cppValue.energyImported.Value().startSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImportedInsideOptional_startSystime);
                }
                else
                {
                    jobject value_energyImportedInsideOptional_startSystimeInsideOptional;
                    std::string value_energyImportedInsideOptional_startSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyImportedInsideOptional_startSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyImportedInsideOptional_startSystimeInsideOptional =
                        static_cast<jlong>(cppValue.energyImported.Value().startSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyImportedInsideOptional_startSystimeInsideOptionalClassName.c_str(),
                        value_energyImportedInsideOptional_startSystimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyImportedInsideOptional_startSystimeInsideOptional,
                        value_energyImportedInsideOptional_startSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyImportedInsideOptional_startSystimeInsideOptional,
                                                                      value_energyImportedInsideOptional_startSystime);
                }
                jobject value_energyImportedInsideOptional_endSystime;
                if (!cppValue.energyImported.Value().endSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImportedInsideOptional_endSystime);
                }
                else
                {
                    jobject value_energyImportedInsideOptional_endSystimeInsideOptional;
                    std::string value_energyImportedInsideOptional_endSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyImportedInsideOptional_endSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyImportedInsideOptional_endSystimeInsideOptional =
                        static_cast<jlong>(cppValue.energyImported.Value().endSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyImportedInsideOptional_endSystimeInsideOptionalClassName.c_str(),
                        value_energyImportedInsideOptional_endSystimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyImportedInsideOptional_endSystimeInsideOptional,
                        value_energyImportedInsideOptional_endSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyImportedInsideOptional_endSystimeInsideOptional,
                                                                      value_energyImportedInsideOptional_endSystime);
                }

                jclass energyMeasurementStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct",
                    energyMeasurementStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct");
                    return nullptr;
                }

                jmethodID energyMeasurementStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(
                    env, energyMeasurementStructStructClass_1, "<init>",
                    "(Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
                    &energyMeasurementStructStructCtor_1);
                if (err != CHIP_NO_ERROR || energyMeasurementStructStructCtor_1 == nullptr)
                {
                    ChipLogError(
                        Zcl, "Could not find ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct constructor");
                    return nullptr;
                }

                value_energyImportedInsideOptional =
                    env->NewObject(energyMeasurementStructStructClass_1, energyMeasurementStructStructCtor_1,
                                   value_energyImportedInsideOptional_energy, value_energyImportedInsideOptional_startTimestamp,
                                   value_energyImportedInsideOptional_endTimestamp, value_energyImportedInsideOptional_startSystime,
                                   value_energyImportedInsideOptional_endSystime);
                chip::JniReferences::GetInstance().CreateOptional(value_energyImportedInsideOptional, value_energyImported);
            }

            jobject value_energyExported;
            if (!cppValue.energyExported.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExported);
            }
            else
            {
                jobject value_energyExportedInsideOptional;
                jobject value_energyExportedInsideOptional_energy;
                std::string value_energyExportedInsideOptional_energyClassName     = "java/lang/Long";
                std::string value_energyExportedInsideOptional_energyCtorSignature = "(J)V";
                jlong jnivalue_energyExportedInsideOptional_energy = static_cast<jlong>(cppValue.energyExported.Value().energy);
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                    value_energyExportedInsideOptional_energyClassName.c_str(),
                    value_energyExportedInsideOptional_energyCtorSignature.c_str(), jnivalue_energyExportedInsideOptional_energy,
                    value_energyExportedInsideOptional_energy);
                jobject value_energyExportedInsideOptional_startTimestamp;
                if (!cppValue.energyExported.Value().startTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExportedInsideOptional_startTimestamp);
                }
                else
                {
                    jobject value_energyExportedInsideOptional_startTimestampInsideOptional;
                    std::string value_energyExportedInsideOptional_startTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyExportedInsideOptional_startTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyExportedInsideOptional_startTimestampInsideOptional =
                        static_cast<jlong>(cppValue.energyExported.Value().startTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyExportedInsideOptional_startTimestampInsideOptionalClassName.c_str(),
                        value_energyExportedInsideOptional_startTimestampInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyExportedInsideOptional_startTimestampInsideOptional,
                        value_energyExportedInsideOptional_startTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(
                        value_energyExportedInsideOptional_startTimestampInsideOptional,
                        value_energyExportedInsideOptional_startTimestamp);
                }
                jobject value_energyExportedInsideOptional_endTimestamp;
                if (!cppValue.energyExported.Value().endTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExportedInsideOptional_endTimestamp);
                }
                else
                {
                    jobject value_energyExportedInsideOptional_endTimestampInsideOptional;
                    std::string value_energyExportedInsideOptional_endTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyExportedInsideOptional_endTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyExportedInsideOptional_endTimestampInsideOptional =
                        static_cast<jlong>(cppValue.energyExported.Value().endTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyExportedInsideOptional_endTimestampInsideOptionalClassName.c_str(),
                        value_energyExportedInsideOptional_endTimestampInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyExportedInsideOptional_endTimestampInsideOptional,
                        value_energyExportedInsideOptional_endTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyExportedInsideOptional_endTimestampInsideOptional,
                                                                      value_energyExportedInsideOptional_endTimestamp);
                }
                jobject value_energyExportedInsideOptional_startSystime;
                if (!cppValue.energyExported.Value().startSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExportedInsideOptional_startSystime);
                }
                else
                {
                    jobject value_energyExportedInsideOptional_startSystimeInsideOptional;
                    std::string value_energyExportedInsideOptional_startSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyExportedInsideOptional_startSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyExportedInsideOptional_startSystimeInsideOptional =
                        static_cast<jlong>(cppValue.energyExported.Value().startSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyExportedInsideOptional_startSystimeInsideOptionalClassName.c_str(),
                        value_energyExportedInsideOptional_startSystimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyExportedInsideOptional_startSystimeInsideOptional,
                        value_energyExportedInsideOptional_startSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyExportedInsideOptional_startSystimeInsideOptional,
                                                                      value_energyExportedInsideOptional_startSystime);
                }
                jobject value_energyExportedInsideOptional_endSystime;
                if (!cppValue.energyExported.Value().endSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExportedInsideOptional_endSystime);
                }
                else
                {
                    jobject value_energyExportedInsideOptional_endSystimeInsideOptional;
                    std::string value_energyExportedInsideOptional_endSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyExportedInsideOptional_endSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyExportedInsideOptional_endSystimeInsideOptional =
                        static_cast<jlong>(cppValue.energyExported.Value().endSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyExportedInsideOptional_endSystimeInsideOptionalClassName.c_str(),
                        value_energyExportedInsideOptional_endSystimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyExportedInsideOptional_endSystimeInsideOptional,
                        value_energyExportedInsideOptional_endSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyExportedInsideOptional_endSystimeInsideOptional,
                                                                      value_energyExportedInsideOptional_endSystime);
                }

                jclass energyMeasurementStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct",
                    energyMeasurementStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct");
                    return nullptr;
                }

                jmethodID energyMeasurementStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(
                    env, energyMeasurementStructStructClass_1, "<init>",
                    "(Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
                    &energyMeasurementStructStructCtor_1);
                if (err != CHIP_NO_ERROR || energyMeasurementStructStructCtor_1 == nullptr)
                {
                    ChipLogError(
                        Zcl, "Could not find ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct constructor");
                    return nullptr;
                }

                value_energyExportedInsideOptional =
                    env->NewObject(energyMeasurementStructStructClass_1, energyMeasurementStructStructCtor_1,
                                   value_energyExportedInsideOptional_energy, value_energyExportedInsideOptional_startTimestamp,
                                   value_energyExportedInsideOptional_endTimestamp, value_energyExportedInsideOptional_startSystime,
                                   value_energyExportedInsideOptional_endSystime);
                chip::JniReferences::GetInstance().CreateOptional(value_energyExportedInsideOptional, value_energyExported);
            }

            jclass cumulativeEnergyMeasuredStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ElectricalEnergyMeasurementClusterCumulativeEnergyMeasuredEvent",
                cumulativeEnergyMeasuredStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(
                    Zcl, "Could not find class ChipEventStructs$ElectricalEnergyMeasurementClusterCumulativeEnergyMeasuredEvent");
                return nullptr;
            }

            jmethodID cumulativeEnergyMeasuredStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, cumulativeEnergyMeasuredStructClass, "<init>",
                                                                "(Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &cumulativeEnergyMeasuredStructCtor);
            if (err != CHIP_NO_ERROR || cumulativeEnergyMeasuredStructCtor == nullptr)
            {
                ChipLogError(
                    Zcl,
                    "Could not find ChipEventStructs$ElectricalEnergyMeasurementClusterCumulativeEnergyMeasuredEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(cumulativeEnergyMeasuredStructClass, cumulativeEnergyMeasuredStructCtor,
                                           value_energyImported, value_energyExported);

            return value;
        }
        case Events::PeriodicEnergyMeasured::Id: {
            Events::PeriodicEnergyMeasured::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_energyImported;
            if (!cppValue.energyImported.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImported);
            }
            else
            {
                jobject value_energyImportedInsideOptional;
                jobject value_energyImportedInsideOptional_energy;
                std::string value_energyImportedInsideOptional_energyClassName     = "java/lang/Long";
                std::string value_energyImportedInsideOptional_energyCtorSignature = "(J)V";
                jlong jnivalue_energyImportedInsideOptional_energy = static_cast<jlong>(cppValue.energyImported.Value().energy);
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                    value_energyImportedInsideOptional_energyClassName.c_str(),
                    value_energyImportedInsideOptional_energyCtorSignature.c_str(), jnivalue_energyImportedInsideOptional_energy,
                    value_energyImportedInsideOptional_energy);
                jobject value_energyImportedInsideOptional_startTimestamp;
                if (!cppValue.energyImported.Value().startTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImportedInsideOptional_startTimestamp);
                }
                else
                {
                    jobject value_energyImportedInsideOptional_startTimestampInsideOptional;
                    std::string value_energyImportedInsideOptional_startTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyImportedInsideOptional_startTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyImportedInsideOptional_startTimestampInsideOptional =
                        static_cast<jlong>(cppValue.energyImported.Value().startTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyImportedInsideOptional_startTimestampInsideOptionalClassName.c_str(),
                        value_energyImportedInsideOptional_startTimestampInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyImportedInsideOptional_startTimestampInsideOptional,
                        value_energyImportedInsideOptional_startTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(
                        value_energyImportedInsideOptional_startTimestampInsideOptional,
                        value_energyImportedInsideOptional_startTimestamp);
                }
                jobject value_energyImportedInsideOptional_endTimestamp;
                if (!cppValue.energyImported.Value().endTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImportedInsideOptional_endTimestamp);
                }
                else
                {
                    jobject value_energyImportedInsideOptional_endTimestampInsideOptional;
                    std::string value_energyImportedInsideOptional_endTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyImportedInsideOptional_endTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyImportedInsideOptional_endTimestampInsideOptional =
                        static_cast<jlong>(cppValue.energyImported.Value().endTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyImportedInsideOptional_endTimestampInsideOptionalClassName.c_str(),
                        value_energyImportedInsideOptional_endTimestampInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyImportedInsideOptional_endTimestampInsideOptional,
                        value_energyImportedInsideOptional_endTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyImportedInsideOptional_endTimestampInsideOptional,
                                                                      value_energyImportedInsideOptional_endTimestamp);
                }
                jobject value_energyImportedInsideOptional_startSystime;
                if (!cppValue.energyImported.Value().startSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImportedInsideOptional_startSystime);
                }
                else
                {
                    jobject value_energyImportedInsideOptional_startSystimeInsideOptional;
                    std::string value_energyImportedInsideOptional_startSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyImportedInsideOptional_startSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyImportedInsideOptional_startSystimeInsideOptional =
                        static_cast<jlong>(cppValue.energyImported.Value().startSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyImportedInsideOptional_startSystimeInsideOptionalClassName.c_str(),
                        value_energyImportedInsideOptional_startSystimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyImportedInsideOptional_startSystimeInsideOptional,
                        value_energyImportedInsideOptional_startSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyImportedInsideOptional_startSystimeInsideOptional,
                                                                      value_energyImportedInsideOptional_startSystime);
                }
                jobject value_energyImportedInsideOptional_endSystime;
                if (!cppValue.energyImported.Value().endSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyImportedInsideOptional_endSystime);
                }
                else
                {
                    jobject value_energyImportedInsideOptional_endSystimeInsideOptional;
                    std::string value_energyImportedInsideOptional_endSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyImportedInsideOptional_endSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyImportedInsideOptional_endSystimeInsideOptional =
                        static_cast<jlong>(cppValue.energyImported.Value().endSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyImportedInsideOptional_endSystimeInsideOptionalClassName.c_str(),
                        value_energyImportedInsideOptional_endSystimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyImportedInsideOptional_endSystimeInsideOptional,
                        value_energyImportedInsideOptional_endSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyImportedInsideOptional_endSystimeInsideOptional,
                                                                      value_energyImportedInsideOptional_endSystime);
                }

                jclass energyMeasurementStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct",
                    energyMeasurementStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct");
                    return nullptr;
                }

                jmethodID energyMeasurementStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(
                    env, energyMeasurementStructStructClass_1, "<init>",
                    "(Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
                    &energyMeasurementStructStructCtor_1);
                if (err != CHIP_NO_ERROR || energyMeasurementStructStructCtor_1 == nullptr)
                {
                    ChipLogError(
                        Zcl, "Could not find ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct constructor");
                    return nullptr;
                }

                value_energyImportedInsideOptional =
                    env->NewObject(energyMeasurementStructStructClass_1, energyMeasurementStructStructCtor_1,
                                   value_energyImportedInsideOptional_energy, value_energyImportedInsideOptional_startTimestamp,
                                   value_energyImportedInsideOptional_endTimestamp, value_energyImportedInsideOptional_startSystime,
                                   value_energyImportedInsideOptional_endSystime);
                chip::JniReferences::GetInstance().CreateOptional(value_energyImportedInsideOptional, value_energyImported);
            }

            jobject value_energyExported;
            if (!cppValue.energyExported.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExported);
            }
            else
            {
                jobject value_energyExportedInsideOptional;
                jobject value_energyExportedInsideOptional_energy;
                std::string value_energyExportedInsideOptional_energyClassName     = "java/lang/Long";
                std::string value_energyExportedInsideOptional_energyCtorSignature = "(J)V";
                jlong jnivalue_energyExportedInsideOptional_energy = static_cast<jlong>(cppValue.energyExported.Value().energy);
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                    value_energyExportedInsideOptional_energyClassName.c_str(),
                    value_energyExportedInsideOptional_energyCtorSignature.c_str(), jnivalue_energyExportedInsideOptional_energy,
                    value_energyExportedInsideOptional_energy);
                jobject value_energyExportedInsideOptional_startTimestamp;
                if (!cppValue.energyExported.Value().startTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExportedInsideOptional_startTimestamp);
                }
                else
                {
                    jobject value_energyExportedInsideOptional_startTimestampInsideOptional;
                    std::string value_energyExportedInsideOptional_startTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyExportedInsideOptional_startTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyExportedInsideOptional_startTimestampInsideOptional =
                        static_cast<jlong>(cppValue.energyExported.Value().startTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyExportedInsideOptional_startTimestampInsideOptionalClassName.c_str(),
                        value_energyExportedInsideOptional_startTimestampInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyExportedInsideOptional_startTimestampInsideOptional,
                        value_energyExportedInsideOptional_startTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(
                        value_energyExportedInsideOptional_startTimestampInsideOptional,
                        value_energyExportedInsideOptional_startTimestamp);
                }
                jobject value_energyExportedInsideOptional_endTimestamp;
                if (!cppValue.energyExported.Value().endTimestamp.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExportedInsideOptional_endTimestamp);
                }
                else
                {
                    jobject value_energyExportedInsideOptional_endTimestampInsideOptional;
                    std::string value_energyExportedInsideOptional_endTimestampInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyExportedInsideOptional_endTimestampInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyExportedInsideOptional_endTimestampInsideOptional =
                        static_cast<jlong>(cppValue.energyExported.Value().endTimestamp.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyExportedInsideOptional_endTimestampInsideOptionalClassName.c_str(),
                        value_energyExportedInsideOptional_endTimestampInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyExportedInsideOptional_endTimestampInsideOptional,
                        value_energyExportedInsideOptional_endTimestampInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyExportedInsideOptional_endTimestampInsideOptional,
                                                                      value_energyExportedInsideOptional_endTimestamp);
                }
                jobject value_energyExportedInsideOptional_startSystime;
                if (!cppValue.energyExported.Value().startSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExportedInsideOptional_startSystime);
                }
                else
                {
                    jobject value_energyExportedInsideOptional_startSystimeInsideOptional;
                    std::string value_energyExportedInsideOptional_startSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyExportedInsideOptional_startSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyExportedInsideOptional_startSystimeInsideOptional =
                        static_cast<jlong>(cppValue.energyExported.Value().startSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyExportedInsideOptional_startSystimeInsideOptionalClassName.c_str(),
                        value_energyExportedInsideOptional_startSystimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyExportedInsideOptional_startSystimeInsideOptional,
                        value_energyExportedInsideOptional_startSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyExportedInsideOptional_startSystimeInsideOptional,
                                                                      value_energyExportedInsideOptional_startSystime);
                }
                jobject value_energyExportedInsideOptional_endSystime;
                if (!cppValue.energyExported.Value().endSystime.HasValue())
                {
                    chip::JniReferences::GetInstance().CreateOptional(nullptr, value_energyExportedInsideOptional_endSystime);
                }
                else
                {
                    jobject value_energyExportedInsideOptional_endSystimeInsideOptional;
                    std::string value_energyExportedInsideOptional_endSystimeInsideOptionalClassName     = "java/lang/Long";
                    std::string value_energyExportedInsideOptional_endSystimeInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_energyExportedInsideOptional_endSystimeInsideOptional =
                        static_cast<jlong>(cppValue.energyExported.Value().endSystime.Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_energyExportedInsideOptional_endSystimeInsideOptionalClassName.c_str(),
                        value_energyExportedInsideOptional_endSystimeInsideOptionalCtorSignature.c_str(),
                        jnivalue_energyExportedInsideOptional_endSystimeInsideOptional,
                        value_energyExportedInsideOptional_endSystimeInsideOptional);
                    chip::JniReferences::GetInstance().CreateOptional(value_energyExportedInsideOptional_endSystimeInsideOptional,
                                                                      value_energyExportedInsideOptional_endSystime);
                }

                jclass energyMeasurementStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct",
                    energyMeasurementStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct");
                    return nullptr;
                }

                jmethodID energyMeasurementStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(
                    env, energyMeasurementStructStructClass_1, "<init>",
                    "(Ljava/lang/Long;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
                    &energyMeasurementStructStructCtor_1);
                if (err != CHIP_NO_ERROR || energyMeasurementStructStructCtor_1 == nullptr)
                {
                    ChipLogError(
                        Zcl, "Could not find ChipStructs$ElectricalEnergyMeasurementClusterEnergyMeasurementStruct constructor");
                    return nullptr;
                }

                value_energyExportedInsideOptional =
                    env->NewObject(energyMeasurementStructStructClass_1, energyMeasurementStructStructCtor_1,
                                   value_energyExportedInsideOptional_energy, value_energyExportedInsideOptional_startTimestamp,
                                   value_energyExportedInsideOptional_endTimestamp, value_energyExportedInsideOptional_startSystime,
                                   value_energyExportedInsideOptional_endSystime);
                chip::JniReferences::GetInstance().CreateOptional(value_energyExportedInsideOptional, value_energyExported);
            }

            jclass periodicEnergyMeasuredStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ElectricalEnergyMeasurementClusterPeriodicEnergyMeasuredEvent",
                periodicEnergyMeasuredStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$ElectricalEnergyMeasurementClusterPeriodicEnergyMeasuredEvent");
                return nullptr;
            }

            jmethodID periodicEnergyMeasuredStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, periodicEnergyMeasuredStructClass, "<init>",
                                                                "(Ljava/util/Optional;Ljava/util/Optional;)V",
                                                                &periodicEnergyMeasuredStructCtor);
            if (err != CHIP_NO_ERROR || periodicEnergyMeasuredStructCtor == nullptr)
            {
                ChipLogError(
                    Zcl,
                    "Could not find ChipEventStructs$ElectricalEnergyMeasurementClusterPeriodicEnergyMeasuredEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(periodicEnergyMeasuredStructClass, periodicEnergyMeasuredStructCtor,
                                           value_energyImported, value_energyExported);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::DemandResponseLoadControl::Id: {
        using namespace app::Clusters::DemandResponseLoadControl;
        switch (aPath.mEventId)
        {
        case Events::LoadControlEventStatusChange::Id: {
            Events::LoadControlEventStatusChange::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_eventID;
            jbyteArray value_eventIDByteArray = env->NewByteArray(static_cast<jsize>(cppValue.eventID.size()));
            env->SetByteArrayRegion(value_eventIDByteArray, 0, static_cast<jsize>(cppValue.eventID.size()),
                                    reinterpret_cast<const jbyte *>(cppValue.eventID.data()));
            value_eventID = value_eventIDByteArray;

            jobject value_transitionIndex;
            if (cppValue.transitionIndex.IsNull())
            {
                value_transitionIndex = nullptr;
            }
            else
            {
                std::string value_transitionIndexClassName     = "java/lang/Integer";
                std::string value_transitionIndexCtorSignature = "(I)V";
                jint jnivalue_transitionIndex                  = static_cast<jint>(cppValue.transitionIndex.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_transitionIndexClassName.c_str(),
                                                                           value_transitionIndexCtorSignature.c_str(),
                                                                           jnivalue_transitionIndex, value_transitionIndex);
            }

            jobject value_status;
            std::string value_statusClassName     = "java/lang/Integer";
            std::string value_statusCtorSignature = "(I)V";
            jint jnivalue_status                  = static_cast<jint>(cppValue.status);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_statusClassName.c_str(), value_statusCtorSignature.c_str(), jnivalue_status, value_status);

            jobject value_criticality;
            std::string value_criticalityClassName     = "java/lang/Integer";
            std::string value_criticalityCtorSignature = "(I)V";
            jint jnivalue_criticality                  = static_cast<jint>(cppValue.criticality);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_criticalityClassName.c_str(),
                                                                       value_criticalityCtorSignature.c_str(), jnivalue_criticality,
                                                                       value_criticality);

            jobject value_control;
            std::string value_controlClassName     = "java/lang/Integer";
            std::string value_controlCtorSignature = "(I)V";
            jint jnivalue_control                  = static_cast<jint>(cppValue.control.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_controlClassName.c_str(), value_controlCtorSignature.c_str(), jnivalue_control, value_control);

            jobject value_temperatureControl;
            if (!cppValue.temperatureControl.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_temperatureControl);
            }
            else
            {
                jobject value_temperatureControlInsideOptional;
                if (cppValue.temperatureControl.Value().IsNull())
                {
                    value_temperatureControlInsideOptional = nullptr;
                }
                else
                {
                    jobject value_temperatureControlInsideOptional_coolingTempOffset;
                    if (!cppValue.temperatureControl.Value().Value().coolingTempOffset.HasValue())
                    {
                        chip::JniReferences::GetInstance().CreateOptional(nullptr,
                                                                          value_temperatureControlInsideOptional_coolingTempOffset);
                    }
                    else
                    {
                        jobject value_temperatureControlInsideOptional_coolingTempOffsetInsideOptional;
                        if (cppValue.temperatureControl.Value().Value().coolingTempOffset.Value().IsNull())
                        {
                            value_temperatureControlInsideOptional_coolingTempOffsetInsideOptional = nullptr;
                        }
                        else
                        {
                            std::string value_temperatureControlInsideOptional_coolingTempOffsetInsideOptionalClassName =
                                "java/lang/Integer";
                            std::string value_temperatureControlInsideOptional_coolingTempOffsetInsideOptionalCtorSignature =
                                "(I)V";
                            jint jnivalue_temperatureControlInsideOptional_coolingTempOffsetInsideOptional =
                                static_cast<jint>(cppValue.temperatureControl.Value().Value().coolingTempOffset.Value().Value());
                            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                                value_temperatureControlInsideOptional_coolingTempOffsetInsideOptionalClassName.c_str(),
                                value_temperatureControlInsideOptional_coolingTempOffsetInsideOptionalCtorSignature.c_str(),
                                jnivalue_temperatureControlInsideOptional_coolingTempOffsetInsideOptional,
                                value_temperatureControlInsideOptional_coolingTempOffsetInsideOptional);
                        }
                        chip::JniReferences::GetInstance().CreateOptional(
                            value_temperatureControlInsideOptional_coolingTempOffsetInsideOptional,
                            value_temperatureControlInsideOptional_coolingTempOffset);
                    }
                    jobject value_temperatureControlInsideOptional_heatingtTempOffset;
                    if (!cppValue.temperatureControl.Value().Value().heatingtTempOffset.HasValue())
                    {
                        chip::JniReferences::GetInstance().CreateOptional(
                            nullptr, value_temperatureControlInsideOptional_heatingtTempOffset);
                    }
                    else
                    {
                        jobject value_temperatureControlInsideOptional_heatingtTempOffsetInsideOptional;
                        if (cppValue.temperatureControl.Value().Value().heatingtTempOffset.Value().IsNull())
                        {
                            value_temperatureControlInsideOptional_heatingtTempOffsetInsideOptional = nullptr;
                        }
                        else
                        {
                            std::string value_temperatureControlInsideOptional_heatingtTempOffsetInsideOptionalClassName =
                                "java/lang/Integer";
                            std::string value_temperatureControlInsideOptional_heatingtTempOffsetInsideOptionalCtorSignature =
                                "(I)V";
                            jint jnivalue_temperatureControlInsideOptional_heatingtTempOffsetInsideOptional =
                                static_cast<jint>(cppValue.temperatureControl.Value().Value().heatingtTempOffset.Value().Value());
                            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                                value_temperatureControlInsideOptional_heatingtTempOffsetInsideOptionalClassName.c_str(),
                                value_temperatureControlInsideOptional_heatingtTempOffsetInsideOptionalCtorSignature.c_str(),
                                jnivalue_temperatureControlInsideOptional_heatingtTempOffsetInsideOptional,
                                value_temperatureControlInsideOptional_heatingtTempOffsetInsideOptional);
                        }
                        chip::JniReferences::GetInstance().CreateOptional(
                            value_temperatureControlInsideOptional_heatingtTempOffsetInsideOptional,
                            value_temperatureControlInsideOptional_heatingtTempOffset);
                    }
                    jobject value_temperatureControlInsideOptional_coolingTempSetpoint;
                    if (!cppValue.temperatureControl.Value().Value().coolingTempSetpoint.HasValue())
                    {
                        chip::JniReferences::GetInstance().CreateOptional(
                            nullptr, value_temperatureControlInsideOptional_coolingTempSetpoint);
                    }
                    else
                    {
                        jobject value_temperatureControlInsideOptional_coolingTempSetpointInsideOptional;
                        if (cppValue.temperatureControl.Value().Value().coolingTempSetpoint.Value().IsNull())
                        {
                            value_temperatureControlInsideOptional_coolingTempSetpointInsideOptional = nullptr;
                        }
                        else
                        {
                            std::string value_temperatureControlInsideOptional_coolingTempSetpointInsideOptionalClassName =
                                "java/lang/Integer";
                            std::string value_temperatureControlInsideOptional_coolingTempSetpointInsideOptionalCtorSignature =
                                "(I)V";
                            jint jnivalue_temperatureControlInsideOptional_coolingTempSetpointInsideOptional =
                                static_cast<jint>(cppValue.temperatureControl.Value().Value().coolingTempSetpoint.Value().Value());
                            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                                value_temperatureControlInsideOptional_coolingTempSetpointInsideOptionalClassName.c_str(),
                                value_temperatureControlInsideOptional_coolingTempSetpointInsideOptionalCtorSignature.c_str(),
                                jnivalue_temperatureControlInsideOptional_coolingTempSetpointInsideOptional,
                                value_temperatureControlInsideOptional_coolingTempSetpointInsideOptional);
                        }
                        chip::JniReferences::GetInstance().CreateOptional(
                            value_temperatureControlInsideOptional_coolingTempSetpointInsideOptional,
                            value_temperatureControlInsideOptional_coolingTempSetpoint);
                    }
                    jobject value_temperatureControlInsideOptional_heatingTempSetpoint;
                    if (!cppValue.temperatureControl.Value().Value().heatingTempSetpoint.HasValue())
                    {
                        chip::JniReferences::GetInstance().CreateOptional(
                            nullptr, value_temperatureControlInsideOptional_heatingTempSetpoint);
                    }
                    else
                    {
                        jobject value_temperatureControlInsideOptional_heatingTempSetpointInsideOptional;
                        if (cppValue.temperatureControl.Value().Value().heatingTempSetpoint.Value().IsNull())
                        {
                            value_temperatureControlInsideOptional_heatingTempSetpointInsideOptional = nullptr;
                        }
                        else
                        {
                            std::string value_temperatureControlInsideOptional_heatingTempSetpointInsideOptionalClassName =
                                "java/lang/Integer";
                            std::string value_temperatureControlInsideOptional_heatingTempSetpointInsideOptionalCtorSignature =
                                "(I)V";
                            jint jnivalue_temperatureControlInsideOptional_heatingTempSetpointInsideOptional =
                                static_cast<jint>(cppValue.temperatureControl.Value().Value().heatingTempSetpoint.Value().Value());
                            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                                value_temperatureControlInsideOptional_heatingTempSetpointInsideOptionalClassName.c_str(),
                                value_temperatureControlInsideOptional_heatingTempSetpointInsideOptionalCtorSignature.c_str(),
                                jnivalue_temperatureControlInsideOptional_heatingTempSetpointInsideOptional,
                                value_temperatureControlInsideOptional_heatingTempSetpointInsideOptional);
                        }
                        chip::JniReferences::GetInstance().CreateOptional(
                            value_temperatureControlInsideOptional_heatingTempSetpointInsideOptional,
                            value_temperatureControlInsideOptional_heatingTempSetpoint);
                    }

                    jclass temperatureControlStructStructClass_2;
                    err = chip::JniReferences::GetInstance().GetLocalClassRef(
                        env, "chip/devicecontroller/ChipStructs$DemandResponseLoadControlClusterTemperatureControlStruct",
                        temperatureControlStructStructClass_2);
                    if (err != CHIP_NO_ERROR)
                    {
                        ChipLogError(Zcl,
                                     "Could not find class ChipStructs$DemandResponseLoadControlClusterTemperatureControlStruct");
                        return nullptr;
                    }

                    jmethodID temperatureControlStructStructCtor_2;
                    err = chip::JniReferences::GetInstance().FindMethod(
                        env, temperatureControlStructStructClass_2, "<init>",
                        "(Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
                        &temperatureControlStructStructCtor_2);
                    if (err != CHIP_NO_ERROR || temperatureControlStructStructCtor_2 == nullptr)
                    {
                        ChipLogError(
                            Zcl, "Could not find ChipStructs$DemandResponseLoadControlClusterTemperatureControlStruct constructor");
                        return nullptr;
                    }

                    value_temperatureControlInsideOptional =
                        env->NewObject(temperatureControlStructStructClass_2, temperatureControlStructStructCtor_2,
                                       value_temperatureControlInsideOptional_coolingTempOffset,
                                       value_temperatureControlInsideOptional_heatingtTempOffset,
                                       value_temperatureControlInsideOptional_coolingTempSetpoint,
                                       value_temperatureControlInsideOptional_heatingTempSetpoint);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_temperatureControlInsideOptional, value_temperatureControl);
            }

            jobject value_averageLoadControl;
            if (!cppValue.averageLoadControl.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_averageLoadControl);
            }
            else
            {
                jobject value_averageLoadControlInsideOptional;
                if (cppValue.averageLoadControl.Value().IsNull())
                {
                    value_averageLoadControlInsideOptional = nullptr;
                }
                else
                {
                    jobject value_averageLoadControlInsideOptional_loadAdjustment;
                    std::string value_averageLoadControlInsideOptional_loadAdjustmentClassName     = "java/lang/Integer";
                    std::string value_averageLoadControlInsideOptional_loadAdjustmentCtorSignature = "(I)V";
                    jint jnivalue_averageLoadControlInsideOptional_loadAdjustment =
                        static_cast<jint>(cppValue.averageLoadControl.Value().Value().loadAdjustment);
                    chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                        value_averageLoadControlInsideOptional_loadAdjustmentClassName.c_str(),
                        value_averageLoadControlInsideOptional_loadAdjustmentCtorSignature.c_str(),
                        jnivalue_averageLoadControlInsideOptional_loadAdjustment,
                        value_averageLoadControlInsideOptional_loadAdjustment);

                    jclass averageLoadControlStructStructClass_2;
                    err = chip::JniReferences::GetInstance().GetLocalClassRef(
                        env, "chip/devicecontroller/ChipStructs$DemandResponseLoadControlClusterAverageLoadControlStruct",
                        averageLoadControlStructStructClass_2);
                    if (err != CHIP_NO_ERROR)
                    {
                        ChipLogError(Zcl,
                                     "Could not find class ChipStructs$DemandResponseLoadControlClusterAverageLoadControlStruct");
                        return nullptr;
                    }

                    jmethodID averageLoadControlStructStructCtor_2;
                    err = chip::JniReferences::GetInstance().FindMethod(env, averageLoadControlStructStructClass_2, "<init>",
                                                                        "(Ljava/lang/Integer;)V",
                                                                        &averageLoadControlStructStructCtor_2);
                    if (err != CHIP_NO_ERROR || averageLoadControlStructStructCtor_2 == nullptr)
                    {
                        ChipLogError(
                            Zcl, "Could not find ChipStructs$DemandResponseLoadControlClusterAverageLoadControlStruct constructor");
                        return nullptr;
                    }

                    value_averageLoadControlInsideOptional =
                        env->NewObject(averageLoadControlStructStructClass_2, averageLoadControlStructStructCtor_2,
                                       value_averageLoadControlInsideOptional_loadAdjustment);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_averageLoadControlInsideOptional, value_averageLoadControl);
            }

            jobject value_dutyCycleControl;
            if (!cppValue.dutyCycleControl.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_dutyCycleControl);
            }
            else
            {
                jobject value_dutyCycleControlInsideOptional;
                if (cppValue.dutyCycleControl.Value().IsNull())
                {
                    value_dutyCycleControlInsideOptional = nullptr;
                }
                else
                {
                    jobject value_dutyCycleControlInsideOptional_dutyCycle;
                    std::string value_dutyCycleControlInsideOptional_dutyCycleClassName     = "java/lang/Integer";
                    std::string value_dutyCycleControlInsideOptional_dutyCycleCtorSignature = "(I)V";
                    jint jnivalue_dutyCycleControlInsideOptional_dutyCycle =
                        static_cast<jint>(cppValue.dutyCycleControl.Value().Value().dutyCycle);
                    chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                        value_dutyCycleControlInsideOptional_dutyCycleClassName.c_str(),
                        value_dutyCycleControlInsideOptional_dutyCycleCtorSignature.c_str(),
                        jnivalue_dutyCycleControlInsideOptional_dutyCycle, value_dutyCycleControlInsideOptional_dutyCycle);

                    jclass dutyCycleControlStructStructClass_2;
                    err = chip::JniReferences::GetInstance().GetLocalClassRef(
                        env, "chip/devicecontroller/ChipStructs$DemandResponseLoadControlClusterDutyCycleControlStruct",
                        dutyCycleControlStructStructClass_2);
                    if (err != CHIP_NO_ERROR)
                    {
                        ChipLogError(Zcl,
                                     "Could not find class ChipStructs$DemandResponseLoadControlClusterDutyCycleControlStruct");
                        return nullptr;
                    }

                    jmethodID dutyCycleControlStructStructCtor_2;
                    err = chip::JniReferences::GetInstance().FindMethod(env, dutyCycleControlStructStructClass_2, "<init>",
                                                                        "(Ljava/lang/Integer;)V",
                                                                        &dutyCycleControlStructStructCtor_2);
                    if (err != CHIP_NO_ERROR || dutyCycleControlStructStructCtor_2 == nullptr)
                    {
                        ChipLogError(
                            Zcl, "Could not find ChipStructs$DemandResponseLoadControlClusterDutyCycleControlStruct constructor");
                        return nullptr;
                    }

                    value_dutyCycleControlInsideOptional =
                        env->NewObject(dutyCycleControlStructStructClass_2, dutyCycleControlStructStructCtor_2,
                                       value_dutyCycleControlInsideOptional_dutyCycle);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_dutyCycleControlInsideOptional, value_dutyCycleControl);
            }

            jobject value_powerSavingsControl;
            if (!cppValue.powerSavingsControl.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_powerSavingsControl);
            }
            else
            {
                jobject value_powerSavingsControlInsideOptional;
                if (cppValue.powerSavingsControl.Value().IsNull())
                {
                    value_powerSavingsControlInsideOptional = nullptr;
                }
                else
                {
                    jobject value_powerSavingsControlInsideOptional_powerSavings;
                    std::string value_powerSavingsControlInsideOptional_powerSavingsClassName     = "java/lang/Integer";
                    std::string value_powerSavingsControlInsideOptional_powerSavingsCtorSignature = "(I)V";
                    jint jnivalue_powerSavingsControlInsideOptional_powerSavings =
                        static_cast<jint>(cppValue.powerSavingsControl.Value().Value().powerSavings);
                    chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                        value_powerSavingsControlInsideOptional_powerSavingsClassName.c_str(),
                        value_powerSavingsControlInsideOptional_powerSavingsCtorSignature.c_str(),
                        jnivalue_powerSavingsControlInsideOptional_powerSavings,
                        value_powerSavingsControlInsideOptional_powerSavings);

                    jclass powerSavingsControlStructStructClass_2;
                    err = chip::JniReferences::GetInstance().GetLocalClassRef(
                        env, "chip/devicecontroller/ChipStructs$DemandResponseLoadControlClusterPowerSavingsControlStruct",
                        powerSavingsControlStructStructClass_2);
                    if (err != CHIP_NO_ERROR)
                    {
                        ChipLogError(Zcl,
                                     "Could not find class ChipStructs$DemandResponseLoadControlClusterPowerSavingsControlStruct");
                        return nullptr;
                    }

                    jmethodID powerSavingsControlStructStructCtor_2;
                    err = chip::JniReferences::GetInstance().FindMethod(env, powerSavingsControlStructStructClass_2, "<init>",
                                                                        "(Ljava/lang/Integer;)V",
                                                                        &powerSavingsControlStructStructCtor_2);
                    if (err != CHIP_NO_ERROR || powerSavingsControlStructStructCtor_2 == nullptr)
                    {
                        ChipLogError(
                            Zcl,
                            "Could not find ChipStructs$DemandResponseLoadControlClusterPowerSavingsControlStruct constructor");
                        return nullptr;
                    }

                    value_powerSavingsControlInsideOptional =
                        env->NewObject(powerSavingsControlStructStructClass_2, powerSavingsControlStructStructCtor_2,
                                       value_powerSavingsControlInsideOptional_powerSavings);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_powerSavingsControlInsideOptional,
                                                                  value_powerSavingsControl);
            }

            jobject value_heatingSourceControl;
            if (!cppValue.heatingSourceControl.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_heatingSourceControl);
            }
            else
            {
                jobject value_heatingSourceControlInsideOptional;
                if (cppValue.heatingSourceControl.Value().IsNull())
                {
                    value_heatingSourceControlInsideOptional = nullptr;
                }
                else
                {
                    jobject value_heatingSourceControlInsideOptional_heatingSource;
                    std::string value_heatingSourceControlInsideOptional_heatingSourceClassName     = "java/lang/Integer";
                    std::string value_heatingSourceControlInsideOptional_heatingSourceCtorSignature = "(I)V";
                    jint jnivalue_heatingSourceControlInsideOptional_heatingSource =
                        static_cast<jint>(cppValue.heatingSourceControl.Value().Value().heatingSource);
                    chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                        value_heatingSourceControlInsideOptional_heatingSourceClassName.c_str(),
                        value_heatingSourceControlInsideOptional_heatingSourceCtorSignature.c_str(),
                        jnivalue_heatingSourceControlInsideOptional_heatingSource,
                        value_heatingSourceControlInsideOptional_heatingSource);

                    jclass heatingSourceControlStructStructClass_2;
                    err = chip::JniReferences::GetInstance().GetLocalClassRef(
                        env, "chip/devicecontroller/ChipStructs$DemandResponseLoadControlClusterHeatingSourceControlStruct",
                        heatingSourceControlStructStructClass_2);
                    if (err != CHIP_NO_ERROR)
                    {
                        ChipLogError(Zcl,
                                     "Could not find class ChipStructs$DemandResponseLoadControlClusterHeatingSourceControlStruct");
                        return nullptr;
                    }

                    jmethodID heatingSourceControlStructStructCtor_2;
                    err = chip::JniReferences::GetInstance().FindMethod(env, heatingSourceControlStructStructClass_2, "<init>",
                                                                        "(Ljava/lang/Integer;)V",
                                                                        &heatingSourceControlStructStructCtor_2);
                    if (err != CHIP_NO_ERROR || heatingSourceControlStructStructCtor_2 == nullptr)
                    {
                        ChipLogError(
                            Zcl,
                            "Could not find ChipStructs$DemandResponseLoadControlClusterHeatingSourceControlStruct constructor");
                        return nullptr;
                    }

                    value_heatingSourceControlInsideOptional =
                        env->NewObject(heatingSourceControlStructStructClass_2, heatingSourceControlStructStructCtor_2,
                                       value_heatingSourceControlInsideOptional_heatingSource);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_heatingSourceControlInsideOptional,
                                                                  value_heatingSourceControl);
            }

            jclass loadControlEventStatusChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DemandResponseLoadControlClusterLoadControlEventStatusChangeEvent",
                loadControlEventStatusChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(
                    Zcl, "Could not find class ChipEventStructs$DemandResponseLoadControlClusterLoadControlEventStatusChangeEvent");
                return nullptr;
            }

            jmethodID loadControlEventStatusChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, loadControlEventStatusChangeStructClass, "<init>",
                "([BLjava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/"
                "Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
                &loadControlEventStatusChangeStructCtor);
            if (err != CHIP_NO_ERROR || loadControlEventStatusChangeStructCtor == nullptr)
            {
                ChipLogError(Zcl,
                             "Could not find ChipEventStructs$DemandResponseLoadControlClusterLoadControlEventStatusChangeEvent "
                             "constructor");
                return nullptr;
            }

            jobject value = env->NewObject(loadControlEventStatusChangeStructClass, loadControlEventStatusChangeStructCtor,
                                           value_eventID, value_transitionIndex, value_status, value_criticality, value_control,
                                           value_temperatureControl, value_averageLoadControl, value_dutyCycleControl,
                                           value_powerSavingsControl, value_heatingSourceControl);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::Messages::Id: {
        using namespace app::Clusters::Messages;
        switch (aPath.mEventId)
        {
        case Events::MessageQueued::Id: {
            Events::MessageQueued::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_messageID;
            jbyteArray value_messageIDByteArray = env->NewByteArray(static_cast<jsize>(cppValue.messageID.size()));
            env->SetByteArrayRegion(value_messageIDByteArray, 0, static_cast<jsize>(cppValue.messageID.size()),
                                    reinterpret_cast<const jbyte *>(cppValue.messageID.data()));
            value_messageID = value_messageIDByteArray;

            jclass messageQueuedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$MessagesClusterMessageQueuedEvent", messageQueuedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$MessagesClusterMessageQueuedEvent");
                return nullptr;
            }

            jmethodID messageQueuedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, messageQueuedStructClass, "<init>", "([B)V",
                                                                &messageQueuedStructCtor);
            if (err != CHIP_NO_ERROR || messageQueuedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$MessagesClusterMessageQueuedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(messageQueuedStructClass, messageQueuedStructCtor, value_messageID);

            return value;
        }
        case Events::MessagePresented::Id: {
            Events::MessagePresented::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_messageID;
            jbyteArray value_messageIDByteArray = env->NewByteArray(static_cast<jsize>(cppValue.messageID.size()));
            env->SetByteArrayRegion(value_messageIDByteArray, 0, static_cast<jsize>(cppValue.messageID.size()),
                                    reinterpret_cast<const jbyte *>(cppValue.messageID.data()));
            value_messageID = value_messageIDByteArray;

            jclass messagePresentedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$MessagesClusterMessagePresentedEvent", messagePresentedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$MessagesClusterMessagePresentedEvent");
                return nullptr;
            }

            jmethodID messagePresentedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, messagePresentedStructClass, "<init>", "([B)V",
                                                                &messagePresentedStructCtor);
            if (err != CHIP_NO_ERROR || messagePresentedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$MessagesClusterMessagePresentedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(messagePresentedStructClass, messagePresentedStructCtor, value_messageID);

            return value;
        }
        case Events::MessageComplete::Id: {
            Events::MessageComplete::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_messageID;
            jbyteArray value_messageIDByteArray = env->NewByteArray(static_cast<jsize>(cppValue.messageID.size()));
            env->SetByteArrayRegion(value_messageIDByteArray, 0, static_cast<jsize>(cppValue.messageID.size()),
                                    reinterpret_cast<const jbyte *>(cppValue.messageID.data()));
            value_messageID = value_messageIDByteArray;

            jobject value_responseID;
            if (!cppValue.responseID.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_responseID);
            }
            else
            {
                jobject value_responseIDInsideOptional;
                if (cppValue.responseID.Value().IsNull())
                {
                    value_responseIDInsideOptional = nullptr;
                }
                else
                {
                    std::string value_responseIDInsideOptionalClassName     = "java/lang/Long";
                    std::string value_responseIDInsideOptionalCtorSignature = "(J)V";
                    jlong jnivalue_responseIDInsideOptional = static_cast<jlong>(cppValue.responseID.Value().Value());
                    chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                        value_responseIDInsideOptionalClassName.c_str(), value_responseIDInsideOptionalCtorSignature.c_str(),
                        jnivalue_responseIDInsideOptional, value_responseIDInsideOptional);
                }
                chip::JniReferences::GetInstance().CreateOptional(value_responseIDInsideOptional, value_responseID);
            }

            jobject value_reply;
            if (!cppValue.reply.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_reply);
            }
            else
            {
                jobject value_replyInsideOptional;
                if (cppValue.reply.Value().IsNull())
                {
                    value_replyInsideOptional = nullptr;
                }
                else
                {
                    LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(cppValue.reply.Value().Value(),
                                                                                         value_replyInsideOptional));
                }
                chip::JniReferences::GetInstance().CreateOptional(value_replyInsideOptional, value_reply);
            }

            jobject value_futureMessagesPreference;
            if (cppValue.futureMessagesPreference.IsNull())
            {
                value_futureMessagesPreference = nullptr;
            }
            else
            {
                std::string value_futureMessagesPreferenceClassName     = "java/lang/Integer";
                std::string value_futureMessagesPreferenceCtorSignature = "(I)V";
                jint jnivalue_futureMessagesPreference = static_cast<jint>(cppValue.futureMessagesPreference.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_futureMessagesPreferenceClassName.c_str(), value_futureMessagesPreferenceCtorSignature.c_str(),
                    jnivalue_futureMessagesPreference, value_futureMessagesPreference);
            }

            jclass messageCompleteStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$MessagesClusterMessageCompleteEvent", messageCompleteStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$MessagesClusterMessageCompleteEvent");
                return nullptr;
            }

            jmethodID messageCompleteStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, messageCompleteStructClass, "<init>",
                                                                "([BLjava/util/Optional;Ljava/util/Optional;Ljava/lang/Integer;)V",
                                                                &messageCompleteStructCtor);
            if (err != CHIP_NO_ERROR || messageCompleteStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$MessagesClusterMessageCompleteEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(messageCompleteStructClass, messageCompleteStructCtor, value_messageID, value_responseID,
                                           value_reply, value_futureMessagesPreference);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::DeviceEnergyManagement::Id: {
        using namespace app::Clusters::DeviceEnergyManagement;
        switch (aPath.mEventId)
        {
        case Events::PowerAdjustStart::Id: {
            Events::PowerAdjustStart::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass powerAdjustStartStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DeviceEnergyManagementClusterPowerAdjustStartEvent",
                powerAdjustStartStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DeviceEnergyManagementClusterPowerAdjustStartEvent");
                return nullptr;
            }

            jmethodID powerAdjustStartStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, powerAdjustStartStructClass, "<init>", "()V",
                                                                &powerAdjustStartStructCtor);
            if (err != CHIP_NO_ERROR || powerAdjustStartStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$DeviceEnergyManagementClusterPowerAdjustStartEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(powerAdjustStartStructClass, powerAdjustStartStructCtor);

            return value;
        }
        case Events::PowerAdjustEnd::Id: {
            Events::PowerAdjustEnd::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_cause;
            std::string value_causeClassName     = "java/lang/Integer";
            std::string value_causeCtorSignature = "(I)V";
            jint jnivalue_cause                  = static_cast<jint>(cppValue.cause);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_causeClassName.c_str(), value_causeCtorSignature.c_str(), jnivalue_cause, value_cause);

            jobject value_duration;
            std::string value_durationClassName     = "java/lang/Long";
            std::string value_durationCtorSignature = "(J)V";
            jlong jnivalue_duration                 = static_cast<jlong>(cppValue.duration);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_durationClassName.c_str(), value_durationCtorSignature.c_str(), jnivalue_duration, value_duration);

            jobject value_energyUse;
            std::string value_energyUseClassName     = "java/lang/Long";
            std::string value_energyUseCtorSignature = "(J)V";
            jlong jnivalue_energyUse                 = static_cast<jlong>(cppValue.energyUse);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_energyUseClassName.c_str(), value_energyUseCtorSignature.c_str(), jnivalue_energyUse, value_energyUse);

            jclass powerAdjustEndStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DeviceEnergyManagementClusterPowerAdjustEndEvent",
                powerAdjustEndStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DeviceEnergyManagementClusterPowerAdjustEndEvent");
                return nullptr;
            }

            jmethodID powerAdjustEndStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, powerAdjustEndStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Long;)V",
                                                                &powerAdjustEndStructCtor);
            if (err != CHIP_NO_ERROR || powerAdjustEndStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$DeviceEnergyManagementClusterPowerAdjustEndEvent constructor");
                return nullptr;
            }

            jobject value =
                env->NewObject(powerAdjustEndStructClass, powerAdjustEndStructCtor, value_cause, value_duration, value_energyUse);

            return value;
        }
        case Events::Paused::Id: {
            Events::Paused::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass pausedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DeviceEnergyManagementClusterPausedEvent", pausedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DeviceEnergyManagementClusterPausedEvent");
                return nullptr;
            }

            jmethodID pausedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, pausedStructClass, "<init>", "()V", &pausedStructCtor);
            if (err != CHIP_NO_ERROR || pausedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$DeviceEnergyManagementClusterPausedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(pausedStructClass, pausedStructCtor);

            return value;
        }
        case Events::Resumed::Id: {
            Events::Resumed::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_cause;
            std::string value_causeClassName     = "java/lang/Integer";
            std::string value_causeCtorSignature = "(I)V";
            jint jnivalue_cause                  = static_cast<jint>(cppValue.cause);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_causeClassName.c_str(), value_causeCtorSignature.c_str(), jnivalue_cause, value_cause);

            jclass resumedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DeviceEnergyManagementClusterResumedEvent", resumedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DeviceEnergyManagementClusterResumedEvent");
                return nullptr;
            }

            jmethodID resumedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, resumedStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &resumedStructCtor);
            if (err != CHIP_NO_ERROR || resumedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$DeviceEnergyManagementClusterResumedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(resumedStructClass, resumedStructCtor, value_cause);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::EnergyEvse::Id: {
        using namespace app::Clusters::EnergyEvse;
        switch (aPath.mEventId)
        {
        case Events::EVConnected::Id: {
            Events::EVConnected::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_sessionID;
            std::string value_sessionIDClassName     = "java/lang/Long";
            std::string value_sessionIDCtorSignature = "(J)V";
            jlong jnivalue_sessionID                 = static_cast<jlong>(cppValue.sessionID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_sessionIDClassName.c_str(), value_sessionIDCtorSignature.c_str(), jnivalue_sessionID, value_sessionID);

            jclass EVConnectedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$EnergyEvseClusterEVConnectedEvent", EVConnectedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$EnergyEvseClusterEVConnectedEvent");
                return nullptr;
            }

            jmethodID EVConnectedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, EVConnectedStructClass, "<init>", "(Ljava/lang/Long;)V",
                                                                &EVConnectedStructCtor);
            if (err != CHIP_NO_ERROR || EVConnectedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$EnergyEvseClusterEVConnectedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(EVConnectedStructClass, EVConnectedStructCtor, value_sessionID);

            return value;
        }
        case Events::EVNotDetected::Id: {
            Events::EVNotDetected::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_sessionID;
            std::string value_sessionIDClassName     = "java/lang/Long";
            std::string value_sessionIDCtorSignature = "(J)V";
            jlong jnivalue_sessionID                 = static_cast<jlong>(cppValue.sessionID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_sessionIDClassName.c_str(), value_sessionIDCtorSignature.c_str(), jnivalue_sessionID, value_sessionID);

            jobject value_state;
            std::string value_stateClassName     = "java/lang/Integer";
            std::string value_stateCtorSignature = "(I)V";
            jint jnivalue_state                  = static_cast<jint>(cppValue.state);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_stateClassName.c_str(), value_stateCtorSignature.c_str(), jnivalue_state, value_state);

            jobject value_sessionDuration;
            std::string value_sessionDurationClassName     = "java/lang/Long";
            std::string value_sessionDurationCtorSignature = "(J)V";
            jlong jnivalue_sessionDuration                 = static_cast<jlong>(cppValue.sessionDuration);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_sessionDurationClassName.c_str(),
                                                                        value_sessionDurationCtorSignature.c_str(),
                                                                        jnivalue_sessionDuration, value_sessionDuration);

            jobject value_sessionEnergyCharged;
            std::string value_sessionEnergyChargedClassName     = "java/lang/Long";
            std::string value_sessionEnergyChargedCtorSignature = "(J)V";
            jlong jnivalue_sessionEnergyCharged                 = static_cast<jlong>(cppValue.sessionEnergyCharged);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_sessionEnergyChargedClassName.c_str(),
                                                                        value_sessionEnergyChargedCtorSignature.c_str(),
                                                                        jnivalue_sessionEnergyCharged, value_sessionEnergyCharged);

            jobject value_sessionEnergyDischarged;
            if (!cppValue.sessionEnergyDischarged.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_sessionEnergyDischarged);
            }
            else
            {
                jobject value_sessionEnergyDischargedInsideOptional;
                std::string value_sessionEnergyDischargedInsideOptionalClassName     = "java/lang/Long";
                std::string value_sessionEnergyDischargedInsideOptionalCtorSignature = "(J)V";
                jlong jnivalue_sessionEnergyDischargedInsideOptional = static_cast<jlong>(cppValue.sessionEnergyDischarged.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                    value_sessionEnergyDischargedInsideOptionalClassName.c_str(),
                    value_sessionEnergyDischargedInsideOptionalCtorSignature.c_str(),
                    jnivalue_sessionEnergyDischargedInsideOptional, value_sessionEnergyDischargedInsideOptional);
                chip::JniReferences::GetInstance().CreateOptional(value_sessionEnergyDischargedInsideOptional,
                                                                  value_sessionEnergyDischarged);
            }

            jclass EVNotDetectedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$EnergyEvseClusterEVNotDetectedEvent", EVNotDetectedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$EnergyEvseClusterEVNotDetectedEvent");
                return nullptr;
            }

            jmethodID EVNotDetectedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, EVNotDetectedStructClass, "<init>",
                "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Long;Ljava/util/Optional;)V",
                &EVNotDetectedStructCtor);
            if (err != CHIP_NO_ERROR || EVNotDetectedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$EnergyEvseClusterEVNotDetectedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(EVNotDetectedStructClass, EVNotDetectedStructCtor, value_sessionID, value_state,
                                           value_sessionDuration, value_sessionEnergyCharged, value_sessionEnergyDischarged);

            return value;
        }
        case Events::EnergyTransferStarted::Id: {
            Events::EnergyTransferStarted::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_sessionID;
            std::string value_sessionIDClassName     = "java/lang/Long";
            std::string value_sessionIDCtorSignature = "(J)V";
            jlong jnivalue_sessionID                 = static_cast<jlong>(cppValue.sessionID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_sessionIDClassName.c_str(), value_sessionIDCtorSignature.c_str(), jnivalue_sessionID, value_sessionID);

            jobject value_state;
            std::string value_stateClassName     = "java/lang/Integer";
            std::string value_stateCtorSignature = "(I)V";
            jint jnivalue_state                  = static_cast<jint>(cppValue.state);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_stateClassName.c_str(), value_stateCtorSignature.c_str(), jnivalue_state, value_state);

            jobject value_maximumCurrent;
            std::string value_maximumCurrentClassName     = "java/lang/Long";
            std::string value_maximumCurrentCtorSignature = "(J)V";
            jlong jnivalue_maximumCurrent                 = static_cast<jlong>(cppValue.maximumCurrent);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_maximumCurrentClassName.c_str(),
                                                                        value_maximumCurrentCtorSignature.c_str(),
                                                                        jnivalue_maximumCurrent, value_maximumCurrent);

            jclass energyTransferStartedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$EnergyEvseClusterEnergyTransferStartedEvent",
                energyTransferStartedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$EnergyEvseClusterEnergyTransferStartedEvent");
                return nullptr;
            }

            jmethodID energyTransferStartedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, energyTransferStartedStructClass, "<init>",
                                                                "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Long;)V",
                                                                &energyTransferStartedStructCtor);
            if (err != CHIP_NO_ERROR || energyTransferStartedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$EnergyEvseClusterEnergyTransferStartedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(energyTransferStartedStructClass, energyTransferStartedStructCtor, value_sessionID,
                                           value_state, value_maximumCurrent);

            return value;
        }
        case Events::EnergyTransferStopped::Id: {
            Events::EnergyTransferStopped::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_sessionID;
            std::string value_sessionIDClassName     = "java/lang/Long";
            std::string value_sessionIDCtorSignature = "(J)V";
            jlong jnivalue_sessionID                 = static_cast<jlong>(cppValue.sessionID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_sessionIDClassName.c_str(), value_sessionIDCtorSignature.c_str(), jnivalue_sessionID, value_sessionID);

            jobject value_state;
            std::string value_stateClassName     = "java/lang/Integer";
            std::string value_stateCtorSignature = "(I)V";
            jint jnivalue_state                  = static_cast<jint>(cppValue.state);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_stateClassName.c_str(), value_stateCtorSignature.c_str(), jnivalue_state, value_state);

            jobject value_reason;
            std::string value_reasonClassName     = "java/lang/Integer";
            std::string value_reasonCtorSignature = "(I)V";
            jint jnivalue_reason                  = static_cast<jint>(cppValue.reason);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_reasonClassName.c_str(), value_reasonCtorSignature.c_str(), jnivalue_reason, value_reason);

            jobject value_energyTransferred;
            std::string value_energyTransferredClassName     = "java/lang/Long";
            std::string value_energyTransferredCtorSignature = "(J)V";
            jlong jnivalue_energyTransferred                 = static_cast<jlong>(cppValue.energyTransferred);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_energyTransferredClassName.c_str(),
                                                                        value_energyTransferredCtorSignature.c_str(),
                                                                        jnivalue_energyTransferred, value_energyTransferred);

            jclass energyTransferStoppedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$EnergyEvseClusterEnergyTransferStoppedEvent",
                energyTransferStoppedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$EnergyEvseClusterEnergyTransferStoppedEvent");
                return nullptr;
            }

            jmethodID energyTransferStoppedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, energyTransferStoppedStructClass, "<init>",
                "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Long;)V", &energyTransferStoppedStructCtor);
            if (err != CHIP_NO_ERROR || energyTransferStoppedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$EnergyEvseClusterEnergyTransferStoppedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(energyTransferStoppedStructClass, energyTransferStoppedStructCtor, value_sessionID,
                                           value_state, value_reason, value_energyTransferred);

            return value;
        }
        case Events::Fault::Id: {
            Events::Fault::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_sessionID;
            if (cppValue.sessionID.IsNull())
            {
                value_sessionID = nullptr;
            }
            else
            {
                std::string value_sessionIDClassName     = "java/lang/Long";
                std::string value_sessionIDCtorSignature = "(J)V";
                jlong jnivalue_sessionID                 = static_cast<jlong>(cppValue.sessionID.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                    value_sessionIDClassName.c_str(), value_sessionIDCtorSignature.c_str(), jnivalue_sessionID, value_sessionID);
            }

            jobject value_state;
            std::string value_stateClassName     = "java/lang/Integer";
            std::string value_stateCtorSignature = "(I)V";
            jint jnivalue_state                  = static_cast<jint>(cppValue.state);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_stateClassName.c_str(), value_stateCtorSignature.c_str(), jnivalue_state, value_state);

            jobject value_faultStatePreviousState;
            std::string value_faultStatePreviousStateClassName     = "java/lang/Integer";
            std::string value_faultStatePreviousStateCtorSignature = "(I)V";
            jint jnivalue_faultStatePreviousState                  = static_cast<jint>(cppValue.faultStatePreviousState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_faultStatePreviousStateClassName.c_str(), value_faultStatePreviousStateCtorSignature.c_str(),
                jnivalue_faultStatePreviousState, value_faultStatePreviousState);

            jobject value_faultStateCurrentState;
            std::string value_faultStateCurrentStateClassName     = "java/lang/Integer";
            std::string value_faultStateCurrentStateCtorSignature = "(I)V";
            jint jnivalue_faultStateCurrentState                  = static_cast<jint>(cppValue.faultStateCurrentState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_faultStateCurrentStateClassName.c_str(), value_faultStateCurrentStateCtorSignature.c_str(),
                jnivalue_faultStateCurrentState, value_faultStateCurrentState);

            jclass faultStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$EnergyEvseClusterFaultEvent", faultStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$EnergyEvseClusterFaultEvent");
                return nullptr;
            }

            jmethodID faultStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, faultStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V",
                &faultStructCtor);
            if (err != CHIP_NO_ERROR || faultStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$EnergyEvseClusterFaultEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(faultStructClass, faultStructCtor, value_sessionID, value_state,
                                           value_faultStatePreviousState, value_faultStateCurrentState);

            return value;
        }
        case Events::Rfid::Id: {
            Events::Rfid::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_uid;
            jbyteArray value_uidByteArray = env->NewByteArray(static_cast<jsize>(cppValue.uid.size()));
            env->SetByteArrayRegion(value_uidByteArray, 0, static_cast<jsize>(cppValue.uid.size()),
                                    reinterpret_cast<const jbyte *>(cppValue.uid.data()));
            value_uid = value_uidByteArray;

            jclass rfidStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$EnergyEvseClusterRfidEvent", rfidStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$EnergyEvseClusterRfidEvent");
                return nullptr;
            }

            jmethodID rfidStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, rfidStructClass, "<init>", "([B)V", &rfidStructCtor);
            if (err != CHIP_NO_ERROR || rfidStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$EnergyEvseClusterRfidEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(rfidStructClass, rfidStructCtor, value_uid);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::EnergyPreference::Id: {
        using namespace app::Clusters::EnergyPreference;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::PowerTopology::Id: {
        using namespace app::Clusters::PowerTopology;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::EnergyEvseMode::Id: {
        using namespace app::Clusters::EnergyEvseMode;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::DeviceEnergyManagementMode::Id: {
        using namespace app::Clusters::DeviceEnergyManagementMode;
        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";
            jint jnivalue_alarmCode                  = static_cast<jint>(cppValue.alarmCode);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_alarmCodeClassName.c_str(), value_alarmCodeCtorSignature.c_str(), jnivalue_alarmCode, value_alarmCode);

            jclass doorLockAlarmStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterDoorLockAlarmEvent", doorLockAlarmStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterDoorLockAlarmEvent");
                return nullptr;
            }

            jmethodID doorLockAlarmStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, doorLockAlarmStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &doorLockAlarmStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_doorState                  = static_cast<jint>(cppValue.doorState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_doorStateClassName.c_str(), value_doorStateCtorSignature.c_str(), jnivalue_doorState, value_doorState);

            jclass doorStateChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterDoorStateChangeEvent", doorStateChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterDoorStateChangeEvent");
                return nullptr;
            }

            jmethodID doorStateChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, doorStateChangeStructClass, "<init>", "(Ljava/lang/Integer;)V",
                                                                &doorStateChangeStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_lockOperationType                  = static_cast<jint>(cppValue.lockOperationType);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_lockOperationTypeClassName.c_str(),
                                                                       value_lockOperationTypeCtorSignature.c_str(),
                                                                       jnivalue_lockOperationType, value_lockOperationType);

            jobject value_operationSource;
            std::string value_operationSourceClassName     = "java/lang/Integer";
            std::string value_operationSourceCtorSignature = "(I)V";
            jint jnivalue_operationSource                  = static_cast<jint>(cppValue.operationSource);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_operationSourceClassName.c_str(),
                                                                       value_operationSourceCtorSignature.c_str(),
                                                                       jnivalue_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";
                jint jnivalue_userIndex                  = static_cast<jint>(cppValue.userIndex.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_userIndexClassName.c_str(), value_userIndexCtorSignature.c_str(), jnivalue_userIndex, 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";
                jint jnivalue_fabricIndex                  = static_cast<jint>(cppValue.fabricIndex.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_fabricIndexClassName.c_str(),
                                                                           value_fabricIndexCtorSignature.c_str(),
                                                                           jnivalue_fabricIndex, 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";
                jlong jnivalue_sourceNode                 = static_cast<jlong>(cppValue.sourceNode.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_sourceNodeClassName.c_str(),
                                                                            value_sourceNodeCtorSignature.c_str(),
                                                                            jnivalue_sourceNode, 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";
                        jint jninewElement_2_credentialType                  = static_cast<jint>(entry_2.credentialType);
                        chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                            newElement_2_credentialTypeClassName.c_str(), newElement_2_credentialTypeCtorSignature.c_str(),
                            jninewElement_2_credentialType, newElement_2_credentialType);
                        jobject newElement_2_credentialIndex;
                        std::string newElement_2_credentialIndexClassName     = "java/lang/Integer";
                        std::string newElement_2_credentialIndexCtorSignature = "(I)V";
                        jint jninewElement_2_credentialIndex                  = static_cast<jint>(entry_2.credentialIndex);
                        chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                            newElement_2_credentialIndexClassName.c_str(), newElement_2_credentialIndexCtorSignature.c_str(),
                            jninewElement_2_credentialIndex, newElement_2_credentialIndex);

                        jclass credentialStructStructClass_3;
                        err = chip::JniReferences::GetInstance().GetLocalClassRef(
                            env, "chip/devicecontroller/ChipStructs$DoorLockClusterCredentialStruct",
                            credentialStructStructClass_3);
                        if (err != CHIP_NO_ERROR)
                        {
                            ChipLogError(Zcl, "Could not find class ChipStructs$DoorLockClusterCredentialStruct");
                            return nullptr;
                        }

                        jmethodID credentialStructStructCtor_3;
                        err = chip::JniReferences::GetInstance().FindMethod(env, credentialStructStructClass_3, "<init>",
                                                                            "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                                            &credentialStructStructCtor_3);
                        if (err != CHIP_NO_ERROR || credentialStructStructCtor_3 == nullptr)
                        {
                            ChipLogError(Zcl, "Could not find ChipStructs$DoorLockClusterCredentialStruct constructor");
                            return nullptr;
                        }

                        newElement_2 = env->NewObject(credentialStructStructClass_3, credentialStructStructCtor_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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterLockOperationEvent", lockOperationStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterLockOperationEvent");
                return nullptr;
            }

            jmethodID lockOperationStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, lockOperationStructClass, "<init>",
                                                                "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/"
                                                                "lang/Integer;Ljava/lang/Long;Ljava/util/Optional;)V",
                                                                &lockOperationStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_lockOperationType                  = static_cast<jint>(cppValue.lockOperationType);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_lockOperationTypeClassName.c_str(),
                                                                       value_lockOperationTypeCtorSignature.c_str(),
                                                                       jnivalue_lockOperationType, value_lockOperationType);

            jobject value_operationSource;
            std::string value_operationSourceClassName     = "java/lang/Integer";
            std::string value_operationSourceCtorSignature = "(I)V";
            jint jnivalue_operationSource                  = static_cast<jint>(cppValue.operationSource);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_operationSourceClassName.c_str(),
                                                                       value_operationSourceCtorSignature.c_str(),
                                                                       jnivalue_operationSource, value_operationSource);

            jobject value_operationError;
            std::string value_operationErrorClassName     = "java/lang/Integer";
            std::string value_operationErrorCtorSignature = "(I)V";
            jint jnivalue_operationError                  = static_cast<jint>(cppValue.operationError);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_operationErrorClassName.c_str(),
                                                                       value_operationErrorCtorSignature.c_str(),
                                                                       jnivalue_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";
                jint jnivalue_userIndex                  = static_cast<jint>(cppValue.userIndex.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_userIndexClassName.c_str(), value_userIndexCtorSignature.c_str(), jnivalue_userIndex, 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";
                jint jnivalue_fabricIndex                  = static_cast<jint>(cppValue.fabricIndex.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_fabricIndexClassName.c_str(),
                                                                           value_fabricIndexCtorSignature.c_str(),
                                                                           jnivalue_fabricIndex, 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";
                jlong jnivalue_sourceNode                 = static_cast<jlong>(cppValue.sourceNode.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_sourceNodeClassName.c_str(),
                                                                            value_sourceNodeCtorSignature.c_str(),
                                                                            jnivalue_sourceNode, 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";
                        jint jninewElement_2_credentialType                  = static_cast<jint>(entry_2.credentialType);
                        chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                            newElement_2_credentialTypeClassName.c_str(), newElement_2_credentialTypeCtorSignature.c_str(),
                            jninewElement_2_credentialType, newElement_2_credentialType);
                        jobject newElement_2_credentialIndex;
                        std::string newElement_2_credentialIndexClassName     = "java/lang/Integer";
                        std::string newElement_2_credentialIndexCtorSignature = "(I)V";
                        jint jninewElement_2_credentialIndex                  = static_cast<jint>(entry_2.credentialIndex);
                        chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                            newElement_2_credentialIndexClassName.c_str(), newElement_2_credentialIndexCtorSignature.c_str(),
                            jninewElement_2_credentialIndex, newElement_2_credentialIndex);

                        jclass credentialStructStructClass_3;
                        err = chip::JniReferences::GetInstance().GetLocalClassRef(
                            env, "chip/devicecontroller/ChipStructs$DoorLockClusterCredentialStruct",
                            credentialStructStructClass_3);
                        if (err != CHIP_NO_ERROR)
                        {
                            ChipLogError(Zcl, "Could not find class ChipStructs$DoorLockClusterCredentialStruct");
                            return nullptr;
                        }

                        jmethodID credentialStructStructCtor_3;
                        err = chip::JniReferences::GetInstance().FindMethod(env, credentialStructStructClass_3, "<init>",
                                                                            "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                                            &credentialStructStructCtor_3);
                        if (err != CHIP_NO_ERROR || credentialStructStructCtor_3 == nullptr)
                        {
                            ChipLogError(Zcl, "Could not find ChipStructs$DoorLockClusterCredentialStruct constructor");
                            return nullptr;
                        }

                        newElement_2 = env->NewObject(credentialStructStructClass_3, credentialStructStructCtor_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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterLockOperationErrorEvent",
                lockOperationErrorStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterLockOperationErrorEvent");
                return nullptr;
            }

            jmethodID lockOperationErrorStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, lockOperationErrorStructClass, "<init>",
                "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/"
                "Long;Ljava/util/Optional;)V",
                &lockOperationErrorStructCtor);
            if (err != CHIP_NO_ERROR || 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";
            jint jnivalue_lockDataType                  = static_cast<jint>(cppValue.lockDataType);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_lockDataTypeClassName.c_str(),
                                                                       value_lockDataTypeCtorSignature.c_str(),
                                                                       jnivalue_lockDataType, value_lockDataType);

            jobject value_dataOperationType;
            std::string value_dataOperationTypeClassName     = "java/lang/Integer";
            std::string value_dataOperationTypeCtorSignature = "(I)V";
            jint jnivalue_dataOperationType                  = static_cast<jint>(cppValue.dataOperationType);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_dataOperationTypeClassName.c_str(),
                                                                       value_dataOperationTypeCtorSignature.c_str(),
                                                                       jnivalue_dataOperationType, value_dataOperationType);

            jobject value_operationSource;
            std::string value_operationSourceClassName     = "java/lang/Integer";
            std::string value_operationSourceCtorSignature = "(I)V";
            jint jnivalue_operationSource                  = static_cast<jint>(cppValue.operationSource);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_operationSourceClassName.c_str(),
                                                                       value_operationSourceCtorSignature.c_str(),
                                                                       jnivalue_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";
                jint jnivalue_userIndex                  = static_cast<jint>(cppValue.userIndex.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_userIndexClassName.c_str(), value_userIndexCtorSignature.c_str(), jnivalue_userIndex, 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";
                jint jnivalue_fabricIndex                  = static_cast<jint>(cppValue.fabricIndex.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_fabricIndexClassName.c_str(),
                                                                           value_fabricIndexCtorSignature.c_str(),
                                                                           jnivalue_fabricIndex, 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";
                jlong jnivalue_sourceNode                 = static_cast<jlong>(cppValue.sourceNode.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_sourceNodeClassName.c_str(),
                                                                            value_sourceNodeCtorSignature.c_str(),
                                                                            jnivalue_sourceNode, 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";
                jint jnivalue_dataIndex                  = static_cast<jint>(cppValue.dataIndex.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    value_dataIndexClassName.c_str(), value_dataIndexCtorSignature.c_str(), jnivalue_dataIndex, value_dataIndex);
            }

            jclass lockUserChangeStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$DoorLockClusterLockUserChangeEvent", lockUserChangeStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$DoorLockClusterLockUserChangeEvent");
                return nullptr;
            }

            jmethodID lockUserChangeStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, lockUserChangeStructClass, "<init>",
                "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/"
                "Long;Ljava/lang/Integer;)V",
                &lockUserChangeStructCtor);
            if (err != CHIP_NO_ERROR || 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::ServiceArea::Id: {
        using namespace app::Clusters::ServiceArea;
        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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageLowEvent",
                supplyVoltageLowStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageLowEvent");
                return nullptr;
            }

            jmethodID supplyVoltageLowStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, supplyVoltageLowStructClass, "<init>", "()V",
                                                                &supplyVoltageLowStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageHighEvent",
                supplyVoltageHighStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSupplyVoltageHighEvent");
                return nullptr;
            }

            jmethodID supplyVoltageHighStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, supplyVoltageHighStructClass, "<init>", "()V",
                                                                &supplyVoltageHighStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterPowerMissingPhaseEvent",
                powerMissingPhaseStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterPowerMissingPhaseEvent");
                return nullptr;
            }

            jmethodID powerMissingPhaseStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, powerMissingPhaseStructClass, "<init>", "()V",
                                                                &powerMissingPhaseStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureLowEvent",
                systemPressureLowStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureLowEvent");
                return nullptr;
            }

            jmethodID systemPressureLowStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, systemPressureLowStructClass, "<init>", "()V",
                                                                &systemPressureLowStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureHighEvent",
                systemPressureHighStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSystemPressureHighEvent");
                return nullptr;
            }

            jmethodID systemPressureHighStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, systemPressureHighStructClass, "<init>", "()V",
                                                                &systemPressureHighStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterDryRunningEvent",
                dryRunningStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterDryRunningEvent");
                return nullptr;
            }

            jmethodID dryRunningStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, dryRunningStructClass, "<init>", "()V", &dryRunningStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterMotorTemperatureHighEvent",
                motorTemperatureHighStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterMotorTemperatureHighEvent");
                return nullptr;
            }

            jmethodID motorTemperatureHighStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, motorTemperatureHighStructClass, "<init>", "()V",
                                                                &motorTemperatureHighStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent",
                pumpMotorFatalFailureStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent");
                return nullptr;
            }

            jmethodID pumpMotorFatalFailureStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, pumpMotorFatalFailureStructClass, "<init>", "()V",
                                                                &pumpMotorFatalFailureStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterElectronicTemperatureHighEvent",
                electronicTemperatureHighStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(
                    Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterElectronicTemperatureHighEvent");
                return nullptr;
            }

            jmethodID electronicTemperatureHighStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, electronicTemperatureHighStructClass, "<init>", "()V",
                                                                &electronicTemperatureHighStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterPumpBlockedEvent",
                pumpBlockedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterPumpBlockedEvent");
                return nullptr;
            }

            jmethodID pumpBlockedStructCtor;
            err =
                chip::JniReferences::GetInstance().FindMethod(env, pumpBlockedStructClass, "<init>", "()V", &pumpBlockedStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterSensorFailureEvent",
                sensorFailureStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterSensorFailureEvent");
                return nullptr;
            }

            jmethodID sensorFailureStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, sensorFailureStructClass, "<init>", "()V",
                                                                &sensorFailureStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent",
                electronicNonFatalFailureStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(
                    Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent");
                return nullptr;
            }

            jmethodID electronicNonFatalFailureStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, electronicNonFatalFailureStructClass, "<init>", "()V",
                                                                &electronicNonFatalFailureStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterElectronicFatalFailureEvent",
                electronicFatalFailureStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl,
                             "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterElectronicFatalFailureEvent");
                return nullptr;
            }

            jmethodID electronicFatalFailureStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, electronicFatalFailureStructClass, "<init>", "()V",
                                                                &electronicFatalFailureStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterGeneralFaultEvent",
                generalFaultStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterGeneralFaultEvent");
                return nullptr;
            }

            jmethodID generalFaultStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, generalFaultStructClass, "<init>", "()V",
                                                                &generalFaultStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterLeakageEvent", leakageStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterLeakageEvent");
                return nullptr;
            }

            jmethodID leakageStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, leakageStructClass, "<init>", "()V", &leakageStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterAirDetectionEvent",
                airDetectionStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterAirDetectionEvent");
                return nullptr;
            }

            jmethodID airDetectionStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, airDetectionStructClass, "<init>", "()V",
                                                                &airDetectionStructCtor);
            if (err != CHIP_NO_ERROR || 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().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$PumpConfigurationAndControlClusterTurbineOperationEvent",
                turbineOperationStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$PumpConfigurationAndControlClusterTurbineOperationEvent");
                return nullptr;
            }

            jmethodID turbineOperationStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, turbineOperationStructClass, "<init>", "()V",
                                                                &turbineOperationStructCtor);
            if (err != CHIP_NO_ERROR || 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::BallastConfiguration::Id: {
        using namespace app::Clusters::BallastConfiguration;
        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::CarbonMonoxideConcentrationMeasurement::Id: {
        using namespace app::Clusters::CarbonMonoxideConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::CarbonDioxideConcentrationMeasurement::Id: {
        using namespace app::Clusters::CarbonDioxideConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::NitrogenDioxideConcentrationMeasurement::Id: {
        using namespace app::Clusters::NitrogenDioxideConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::OzoneConcentrationMeasurement::Id: {
        using namespace app::Clusters::OzoneConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::Pm25ConcentrationMeasurement::Id: {
        using namespace app::Clusters::Pm25ConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::FormaldehydeConcentrationMeasurement::Id: {
        using namespace app::Clusters::FormaldehydeConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::Pm1ConcentrationMeasurement::Id: {
        using namespace app::Clusters::Pm1ConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::Pm10ConcentrationMeasurement::Id: {
        using namespace app::Clusters::Pm10ConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id: {
        using namespace app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::RadonConcentrationMeasurement::Id: {
        using namespace app::Clusters::RadonConcentrationMeasurement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::WiFiNetworkManagement::Id: {
        using namespace app::Clusters::WiFiNetworkManagement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ThreadBorderRouterManagement::Id: {
        using namespace app::Clusters::ThreadBorderRouterManagement;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ThreadNetworkDirectory::Id: {
        using namespace app::Clusters::ThreadNetworkDirectory;
        switch (aPath.mEventId)
        {
        case Events::NetworkChanged::Id: {
            Events::NetworkChanged::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_extendedPanID;
            std::string value_extendedPanIDClassName     = "java/lang/Long";
            std::string value_extendedPanIDCtorSignature = "(J)V";
            jlong jnivalue_extendedPanID                 = static_cast<jlong>(cppValue.extendedPanID);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_extendedPanIDClassName.c_str(),
                                                                        value_extendedPanIDCtorSignature.c_str(),
                                                                        jnivalue_extendedPanID, value_extendedPanID);

            jclass networkChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ThreadNetworkDirectoryClusterNetworkChangedEvent",
                networkChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$ThreadNetworkDirectoryClusterNetworkChangedEvent");
                return nullptr;
            }

            jmethodID networkChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, networkChangedStructClass, "<init>", "(Ljava/lang/Long;)V",
                                                                &networkChangedStructCtor);
            if (err != CHIP_NO_ERROR || networkChangedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$ThreadNetworkDirectoryClusterNetworkChangedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(networkChangedStructClass, networkChangedStructCtor, value_extendedPanID);

            return value;
        }
        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)
        {
        case Events::TargetUpdated::Id: {
            Events::TargetUpdated::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_targetList;
            chip::JniReferences::GetInstance().CreateArrayList(value_targetList);

            auto iter_value_targetList_0 = cppValue.targetList.begin();
            while (iter_value_targetList_0.Next())
            {
                auto & entry_0 = iter_value_targetList_0.GetValue();
                jobject newElement_0;
                jobject newElement_0_identifier;
                std::string newElement_0_identifierClassName     = "java/lang/Integer";
                std::string newElement_0_identifierCtorSignature = "(I)V";
                jint jninewElement_0_identifier                  = static_cast<jint>(entry_0.identifier);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(newElement_0_identifierClassName.c_str(),
                                                                           newElement_0_identifierCtorSignature.c_str(),
                                                                           jninewElement_0_identifier, newElement_0_identifier);
                jobject newElement_0_name;
                LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(entry_0.name, newElement_0_name));

                jclass targetInfoStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$TargetNavigatorClusterTargetInfoStruct", targetInfoStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$TargetNavigatorClusterTargetInfoStruct");
                    return nullptr;
                }

                jmethodID targetInfoStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(env, targetInfoStructStructClass_1, "<init>",
                                                                    "(Ljava/lang/Integer;Ljava/lang/String;)V",
                                                                    &targetInfoStructStructCtor_1);
                if (err != CHIP_NO_ERROR || targetInfoStructStructCtor_1 == nullptr)
                {
                    ChipLogError(Zcl, "Could not find ChipStructs$TargetNavigatorClusterTargetInfoStruct constructor");
                    return nullptr;
                }

                newElement_0 = env->NewObject(targetInfoStructStructClass_1, targetInfoStructStructCtor_1, newElement_0_identifier,
                                              newElement_0_name);
                chip::JniReferences::GetInstance().AddToList(value_targetList, newElement_0);
            }

            jobject value_currentTarget;
            std::string value_currentTargetClassName     = "java/lang/Integer";
            std::string value_currentTargetCtorSignature = "(I)V";
            jint jnivalue_currentTarget                  = static_cast<jint>(cppValue.currentTarget);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_currentTargetClassName.c_str(),
                                                                       value_currentTargetCtorSignature.c_str(),
                                                                       jnivalue_currentTarget, value_currentTarget);

            jobject value_data;
            jbyteArray value_dataByteArray = env->NewByteArray(static_cast<jsize>(cppValue.data.size()));
            env->SetByteArrayRegion(value_dataByteArray, 0, static_cast<jsize>(cppValue.data.size()),
                                    reinterpret_cast<const jbyte *>(cppValue.data.data()));
            value_data = value_dataByteArray;

            jclass targetUpdatedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$TargetNavigatorClusterTargetUpdatedEvent", targetUpdatedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$TargetNavigatorClusterTargetUpdatedEvent");
                return nullptr;
            }

            jmethodID targetUpdatedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, targetUpdatedStructClass, "<init>", "(Ljava/util/ArrayList;Ljava/lang/Integer;[B)V", &targetUpdatedStructCtor);
            if (err != CHIP_NO_ERROR || targetUpdatedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$TargetNavigatorClusterTargetUpdatedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(targetUpdatedStructClass, targetUpdatedStructCtor, value_targetList, value_currentTarget,
                                           value_data);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::MediaPlayback::Id: {
        using namespace app::Clusters::MediaPlayback;
        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_currentState;
            std::string value_currentStateClassName     = "java/lang/Integer";
            std::string value_currentStateCtorSignature = "(I)V";
            jint jnivalue_currentState                  = static_cast<jint>(cppValue.currentState);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_currentStateClassName.c_str(),
                                                                       value_currentStateCtorSignature.c_str(),
                                                                       jnivalue_currentState, value_currentState);

            jobject value_startTime;
            std::string value_startTimeClassName     = "java/lang/Long";
            std::string value_startTimeCtorSignature = "(J)V";
            jlong jnivalue_startTime                 = static_cast<jlong>(cppValue.startTime);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_startTimeClassName.c_str(), value_startTimeCtorSignature.c_str(), jnivalue_startTime, value_startTime);

            jobject value_duration;
            std::string value_durationClassName     = "java/lang/Long";
            std::string value_durationCtorSignature = "(J)V";
            jlong jnivalue_duration                 = static_cast<jlong>(cppValue.duration);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_durationClassName.c_str(), value_durationCtorSignature.c_str(), jnivalue_duration, value_duration);

            jobject value_sampledPosition;
            jobject value_sampledPosition_updatedAt;
            std::string value_sampledPosition_updatedAtClassName     = "java/lang/Long";
            std::string value_sampledPosition_updatedAtCtorSignature = "(J)V";
            jlong jnivalue_sampledPosition_updatedAt                 = static_cast<jlong>(cppValue.sampledPosition.updatedAt);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_sampledPosition_updatedAtClassName.c_str(), value_sampledPosition_updatedAtCtorSignature.c_str(),
                jnivalue_sampledPosition_updatedAt, value_sampledPosition_updatedAt);
            jobject value_sampledPosition_position;
            if (cppValue.sampledPosition.position.IsNull())
            {
                value_sampledPosition_position = nullptr;
            }
            else
            {
                std::string value_sampledPosition_positionClassName     = "java/lang/Long";
                std::string value_sampledPosition_positionCtorSignature = "(J)V";
                jlong jnivalue_sampledPosition_position = static_cast<jlong>(cppValue.sampledPosition.position.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                    value_sampledPosition_positionClassName.c_str(), value_sampledPosition_positionCtorSignature.c_str(),
                    jnivalue_sampledPosition_position, value_sampledPosition_position);
            }

            jclass playbackPositionStructStructClass_0;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipStructs$MediaPlaybackClusterPlaybackPositionStruct",
                playbackPositionStructStructClass_0);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipStructs$MediaPlaybackClusterPlaybackPositionStruct");
                return nullptr;
            }

            jmethodID playbackPositionStructStructCtor_0;
            err = chip::JniReferences::GetInstance().FindMethod(env, playbackPositionStructStructClass_0, "<init>",
                                                                "(Ljava/lang/Long;Ljava/lang/Long;)V",
                                                                &playbackPositionStructStructCtor_0);
            if (err != CHIP_NO_ERROR || playbackPositionStructStructCtor_0 == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipStructs$MediaPlaybackClusterPlaybackPositionStruct constructor");
                return nullptr;
            }

            value_sampledPosition = env->NewObject(playbackPositionStructStructClass_0, playbackPositionStructStructCtor_0,
                                                   value_sampledPosition_updatedAt, value_sampledPosition_position);

            jobject value_playbackSpeed;
            std::string value_playbackSpeedClassName     = "java/lang/Float";
            std::string value_playbackSpeedCtorSignature = "(F)V";
            jfloat jnivalue_playbackSpeed                = static_cast<jfloat>(cppValue.playbackSpeed);
            chip::JniReferences::GetInstance().CreateBoxedObject<jfloat>(value_playbackSpeedClassName.c_str(),
                                                                         value_playbackSpeedCtorSignature.c_str(),
                                                                         jnivalue_playbackSpeed, value_playbackSpeed);

            jobject value_seekRangeEnd;
            std::string value_seekRangeEndClassName     = "java/lang/Long";
            std::string value_seekRangeEndCtorSignature = "(J)V";
            jlong jnivalue_seekRangeEnd                 = static_cast<jlong>(cppValue.seekRangeEnd);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_seekRangeEndClassName.c_str(),
                                                                        value_seekRangeEndCtorSignature.c_str(),
                                                                        jnivalue_seekRangeEnd, value_seekRangeEnd);

            jobject value_seekRangeStart;
            std::string value_seekRangeStartClassName     = "java/lang/Long";
            std::string value_seekRangeStartCtorSignature = "(J)V";
            jlong jnivalue_seekRangeStart                 = static_cast<jlong>(cppValue.seekRangeStart);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_seekRangeStartClassName.c_str(),
                                                                        value_seekRangeStartCtorSignature.c_str(),
                                                                        jnivalue_seekRangeStart, value_seekRangeStart);

            jobject value_data;
            if (!cppValue.data.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_data);
            }
            else
            {
                jobject value_dataInsideOptional;
                jbyteArray value_dataInsideOptionalByteArray = env->NewByteArray(static_cast<jsize>(cppValue.data.Value().size()));
                env->SetByteArrayRegion(value_dataInsideOptionalByteArray, 0, static_cast<jsize>(cppValue.data.Value().size()),
                                        reinterpret_cast<const jbyte *>(cppValue.data.Value().data()));
                value_dataInsideOptional = value_dataInsideOptionalByteArray;
                chip::JniReferences::GetInstance().CreateOptional(value_dataInsideOptional, value_data);
            }

            jobject value_audioAdvanceUnmuted;
            std::string value_audioAdvanceUnmutedClassName     = "java/lang/Boolean";
            std::string value_audioAdvanceUnmutedCtorSignature = "(Z)V";
            jboolean jnivalue_audioAdvanceUnmuted              = static_cast<jboolean>(cppValue.audioAdvanceUnmuted);
            chip::JniReferences::GetInstance().CreateBoxedObject<jboolean>(value_audioAdvanceUnmutedClassName.c_str(),
                                                                           value_audioAdvanceUnmutedCtorSignature.c_str(),
                                                                           jnivalue_audioAdvanceUnmuted, value_audioAdvanceUnmuted);

            jclass stateChangedStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$MediaPlaybackClusterStateChangedEvent", stateChangedStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$MediaPlaybackClusterStateChangedEvent");
                return nullptr;
            }

            jmethodID stateChangedStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, stateChangedStructClass, "<init>",
                "(Ljava/lang/Integer;Ljava/lang/Long;Ljava/lang/Long;Lchip/devicecontroller/"
                "ChipStructs$MediaPlaybackClusterPlaybackPositionStruct;Ljava/lang/Float;Ljava/lang/Long;Ljava/lang/Long;Ljava/"
                "util/Optional;Ljava/lang/Boolean;)V",
                &stateChangedStructCtor);
            if (err != CHIP_NO_ERROR || stateChangedStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$MediaPlaybackClusterStateChangedEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(stateChangedStructClass, stateChangedStructCtor, value_currentState, value_startTime,
                                           value_duration, value_sampledPosition, value_playbackSpeed, value_seekRangeEnd,
                                           value_seekRangeStart, value_data, value_audioAdvanceUnmuted);

            return value;
        }
        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)
        {
        case Events::LoggedOut::Id: {
            Events::LoggedOut::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_node;
            if (!cppValue.node.HasValue())
            {
                chip::JniReferences::GetInstance().CreateOptional(nullptr, value_node);
            }
            else
            {
                jobject value_nodeInsideOptional;
                std::string value_nodeInsideOptionalClassName     = "java/lang/Long";
                std::string value_nodeInsideOptionalCtorSignature = "(J)V";
                jlong jnivalue_nodeInsideOptional                 = static_cast<jlong>(cppValue.node.Value());
                chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(value_nodeInsideOptionalClassName.c_str(),
                                                                            value_nodeInsideOptionalCtorSignature.c_str(),
                                                                            jnivalue_nodeInsideOptional, value_nodeInsideOptional);
                chip::JniReferences::GetInstance().CreateOptional(value_nodeInsideOptional, value_node);
            }

            jclass loggedOutStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$AccountLoginClusterLoggedOutEvent", loggedOutStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$AccountLoginClusterLoggedOutEvent");
                return nullptr;
            }

            jmethodID loggedOutStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, loggedOutStructClass, "<init>", "(Ljava/util/Optional;)V",
                                                                &loggedOutStructCtor);
            if (err != CHIP_NO_ERROR || loggedOutStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$AccountLoginClusterLoggedOutEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(loggedOutStructClass, loggedOutStructCtor, value_node);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ContentControl::Id: {
        using namespace app::Clusters::ContentControl;
        switch (aPath.mEventId)
        {
        case Events::RemainingScreenTimeExpired::Id: {
            Events::RemainingScreenTimeExpired::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jclass remainingScreenTimeExpiredStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$ContentControlClusterRemainingScreenTimeExpiredEvent",
                remainingScreenTimeExpiredStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$ContentControlClusterRemainingScreenTimeExpiredEvent");
                return nullptr;
            }

            jmethodID remainingScreenTimeExpiredStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, remainingScreenTimeExpiredStructClass, "<init>", "()V",
                                                                &remainingScreenTimeExpiredStructCtor);
            if (err != CHIP_NO_ERROR || remainingScreenTimeExpiredStructCtor == nullptr)
            {
                ChipLogError(Zcl,
                             "Could not find ChipEventStructs$ContentControlClusterRemainingScreenTimeExpiredEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(remainingScreenTimeExpiredStructClass, remainingScreenTimeExpiredStructCtor);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::ContentAppObserver::Id: {
        using namespace app::Clusters::ContentAppObserver;
        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::UnitTesting::Id: {
        using namespace app::Clusters::UnitTesting;
        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";
            jint jnivalue_arg1                  = static_cast<jint>(cppValue.arg1);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_arg1ClassName.c_str(), value_arg1CtorSignature.c_str(),
                                                                       jnivalue_arg1, value_arg1);

            jobject value_arg2;
            std::string value_arg2ClassName     = "java/lang/Integer";
            std::string value_arg2CtorSignature = "(I)V";
            jint jnivalue_arg2                  = static_cast<jint>(cppValue.arg2);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_arg2ClassName.c_str(), value_arg2CtorSignature.c_str(),
                                                                       jnivalue_arg2, value_arg2);

            jobject value_arg3;
            std::string value_arg3ClassName     = "java/lang/Boolean";
            std::string value_arg3CtorSignature = "(Z)V";
            jboolean jnivalue_arg3              = static_cast<jboolean>(cppValue.arg3);
            chip::JniReferences::GetInstance().CreateBoxedObject<jboolean>(
                value_arg3ClassName.c_str(), value_arg3CtorSignature.c_str(), jnivalue_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";
            jint jnivalue_arg4_a                  = static_cast<jint>(cppValue.arg4.a);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_arg4_aClassName.c_str(), value_arg4_aCtorSignature.c_str(), jnivalue_arg4_a, value_arg4_a);
            jobject value_arg4_b;
            std::string value_arg4_bClassName     = "java/lang/Boolean";
            std::string value_arg4_bCtorSignature = "(Z)V";
            jboolean jnivalue_arg4_b              = static_cast<jboolean>(cppValue.arg4.b);
            chip::JniReferences::GetInstance().CreateBoxedObject<jboolean>(
                value_arg4_bClassName.c_str(), value_arg4_bCtorSignature.c_str(), jnivalue_arg4_b, value_arg4_b);
            jobject value_arg4_c;
            std::string value_arg4_cClassName     = "java/lang/Integer";
            std::string value_arg4_cCtorSignature = "(I)V";
            jint jnivalue_arg4_c                  = static_cast<jint>(cppValue.arg4.c);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_arg4_cClassName.c_str(), value_arg4_cCtorSignature.c_str(), jnivalue_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;
            LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(cppValue.arg4.e, value_arg4_e));
            jobject value_arg4_f;
            std::string value_arg4_fClassName     = "java/lang/Integer";
            std::string value_arg4_fCtorSignature = "(I)V";
            jint jnivalue_arg4_f                  = static_cast<jint>(cppValue.arg4.f.Raw());
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                value_arg4_fClassName.c_str(), value_arg4_fCtorSignature.c_str(), jnivalue_arg4_f, value_arg4_f);
            jobject value_arg4_g;
            std::string value_arg4_gClassName     = "java/lang/Float";
            std::string value_arg4_gCtorSignature = "(F)V";
            jfloat jnivalue_arg4_g                = static_cast<jfloat>(cppValue.arg4.g);
            chip::JniReferences::GetInstance().CreateBoxedObject<jfloat>(
                value_arg4_gClassName.c_str(), value_arg4_gCtorSignature.c_str(), jnivalue_arg4_g, value_arg4_g);
            jobject value_arg4_h;
            std::string value_arg4_hClassName     = "java/lang/Double";
            std::string value_arg4_hCtorSignature = "(D)V";
            jdouble jnivalue_arg4_h               = static_cast<jdouble>(cppValue.arg4.h);
            chip::JniReferences::GetInstance().CreateBoxedObject<jdouble>(
                value_arg4_hClassName.c_str(), value_arg4_hCtorSignature.c_str(), jnivalue_arg4_h, value_arg4_h);

            jclass simpleStructStructClass_0;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipStructs$UnitTestingClusterSimpleStruct", simpleStructStructClass_0);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipStructs$UnitTestingClusterSimpleStruct");
                return nullptr;
            }

            jmethodID simpleStructStructCtor_0;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, 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",
                &simpleStructStructCtor_0);
            if (err != CHIP_NO_ERROR || simpleStructStructCtor_0 == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipStructs$UnitTestingClusterSimpleStruct 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";
                jint jninewElement_0_a                  = static_cast<jint>(entry_0.a);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0_aClassName.c_str(), newElement_0_aCtorSignature.c_str(), jninewElement_0_a, newElement_0_a);
                jobject newElement_0_b;
                std::string newElement_0_bClassName     = "java/lang/Boolean";
                std::string newElement_0_bCtorSignature = "(Z)V";
                jboolean jninewElement_0_b              = static_cast<jboolean>(entry_0.b);
                chip::JniReferences::GetInstance().CreateBoxedObject<jboolean>(
                    newElement_0_bClassName.c_str(), newElement_0_bCtorSignature.c_str(), jninewElement_0_b, newElement_0_b);
                jobject newElement_0_c;
                std::string newElement_0_cClassName     = "java/lang/Integer";
                std::string newElement_0_cCtorSignature = "(I)V";
                jint jninewElement_0_c                  = static_cast<jint>(entry_0.c);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0_cClassName.c_str(), newElement_0_cCtorSignature.c_str(), jninewElement_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;
                LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(entry_0.e, newElement_0_e));
                jobject newElement_0_f;
                std::string newElement_0_fClassName     = "java/lang/Integer";
                std::string newElement_0_fCtorSignature = "(I)V";
                jint jninewElement_0_f                  = static_cast<jint>(entry_0.f.Raw());
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0_fClassName.c_str(), newElement_0_fCtorSignature.c_str(), jninewElement_0_f, newElement_0_f);
                jobject newElement_0_g;
                std::string newElement_0_gClassName     = "java/lang/Float";
                std::string newElement_0_gCtorSignature = "(F)V";
                jfloat jninewElement_0_g                = static_cast<jfloat>(entry_0.g);
                chip::JniReferences::GetInstance().CreateBoxedObject<jfloat>(
                    newElement_0_gClassName.c_str(), newElement_0_gCtorSignature.c_str(), jninewElement_0_g, newElement_0_g);
                jobject newElement_0_h;
                std::string newElement_0_hClassName     = "java/lang/Double";
                std::string newElement_0_hCtorSignature = "(D)V";
                jdouble jninewElement_0_h               = static_cast<jdouble>(entry_0.h);
                chip::JniReferences::GetInstance().CreateBoxedObject<jdouble>(
                    newElement_0_hClassName.c_str(), newElement_0_hCtorSignature.c_str(), jninewElement_0_h, newElement_0_h);

                jclass simpleStructStructClass_1;
                err = chip::JniReferences::GetInstance().GetLocalClassRef(
                    env, "chip/devicecontroller/ChipStructs$UnitTestingClusterSimpleStruct", simpleStructStructClass_1);
                if (err != CHIP_NO_ERROR)
                {
                    ChipLogError(Zcl, "Could not find class ChipStructs$UnitTestingClusterSimpleStruct");
                    return nullptr;
                }

                jmethodID simpleStructStructCtor_1;
                err = chip::JniReferences::GetInstance().FindMethod(
                    env, 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",
                    &simpleStructStructCtor_1);
                if (err != CHIP_NO_ERROR || simpleStructStructCtor_1 == nullptr)
                {
                    ChipLogError(Zcl, "Could not find ChipStructs$UnitTestingClusterSimpleStruct 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";
                jint jninewElement_0                  = static_cast<jint>(entry_0);
                chip::JniReferences::GetInstance().CreateBoxedObject<jint>(
                    newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
                chip::JniReferences::GetInstance().AddToList(value_arg6, newElement_0);
            }

            jclass testEventStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$UnitTestingClusterTestEventEvent", testEventStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$UnitTestingClusterTestEventEvent");
                return nullptr;
            }

            jmethodID testEventStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, testEventStructClass, "<init>",
                "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Boolean;Lchip/devicecontroller/"
                "ChipStructs$UnitTestingClusterSimpleStruct;Ljava/util/ArrayList;Ljava/util/ArrayList;)V",
                &testEventStructCtor);
            if (err != CHIP_NO_ERROR || testEventStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$UnitTestingClusterTestEventEvent 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_fabricIndex;
            std::string value_fabricIndexClassName     = "java/lang/Integer";
            std::string value_fabricIndexCtorSignature = "(I)V";
            jint jnivalue_fabricIndex                  = static_cast<jint>(cppValue.fabricIndex);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_fabricIndexClassName.c_str(),
                                                                       value_fabricIndexCtorSignature.c_str(), jnivalue_fabricIndex,
                                                                       value_fabricIndex);

            jclass testFabricScopedEventStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$UnitTestingClusterTestFabricScopedEventEvent",
                testFabricScopedEventStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$UnitTestingClusterTestFabricScopedEventEvent");
                return nullptr;
            }

            jmethodID testFabricScopedEventStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, testFabricScopedEventStructClass, "<init>",
                                                                "(Ljava/lang/Integer;)V", &testFabricScopedEventStructCtor);
            if (err != CHIP_NO_ERROR || testFabricScopedEventStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$UnitTestingClusterTestFabricScopedEventEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(testFabricScopedEventStructClass, testFabricScopedEventStructCtor, value_fabricIndex);

            return value;
        }
        case Events::TestDifferentVendorMeiEvent::Id: {
            Events::TestDifferentVendorMeiEvent::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";
            jint jnivalue_arg1                  = static_cast<jint>(cppValue.arg1);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_arg1ClassName.c_str(), value_arg1CtorSignature.c_str(),
                                                                       jnivalue_arg1, value_arg1);

            jclass testDifferentVendorMeiEventStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$UnitTestingClusterTestDifferentVendorMeiEventEvent",
                testDifferentVendorMeiEventStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$UnitTestingClusterTestDifferentVendorMeiEventEvent");
                return nullptr;
            }

            jmethodID testDifferentVendorMeiEventStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(env, testDifferentVendorMeiEventStructClass, "<init>",
                                                                "(Ljava/lang/Integer;)V", &testDifferentVendorMeiEventStructCtor);
            if (err != CHIP_NO_ERROR || testDifferentVendorMeiEventStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$UnitTestingClusterTestDifferentVendorMeiEventEvent constructor");
                return nullptr;
            }

            jobject value =
                env->NewObject(testDifferentVendorMeiEventStructClass, testDifferentVendorMeiEventStructCtor, value_arg1);

            return value;
        }
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::FaultInjection::Id: {
        using namespace app::Clusters::FaultInjection;
        switch (aPath.mEventId)
        {
        default:
            *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
            break;
        }
        break;
    }
    case app::Clusters::SampleMei::Id: {
        using namespace app::Clusters::SampleMei;
        switch (aPath.mEventId)
        {
        case Events::PingCountEvent::Id: {
            Events::PingCountEvent::DecodableType cppValue;
            *aError = app::DataModel::Decode(aReader, cppValue);
            if (*aError != CHIP_NO_ERROR)
            {
                return nullptr;
            }
            jobject value_count;
            std::string value_countClassName     = "java/lang/Long";
            std::string value_countCtorSignature = "(J)V";
            jlong jnivalue_count                 = static_cast<jlong>(cppValue.count);
            chip::JniReferences::GetInstance().CreateBoxedObject<jlong>(
                value_countClassName.c_str(), value_countCtorSignature.c_str(), jnivalue_count, value_count);

            jobject value_fabricIndex;
            std::string value_fabricIndexClassName     = "java/lang/Integer";
            std::string value_fabricIndexCtorSignature = "(I)V";
            jint jnivalue_fabricIndex                  = static_cast<jint>(cppValue.fabricIndex);
            chip::JniReferences::GetInstance().CreateBoxedObject<jint>(value_fabricIndexClassName.c_str(),
                                                                       value_fabricIndexCtorSignature.c_str(), jnivalue_fabricIndex,
                                                                       value_fabricIndex);

            jclass pingCountEventStructClass;
            err = chip::JniReferences::GetInstance().GetLocalClassRef(
                env, "chip/devicecontroller/ChipEventStructs$SampleMeiClusterPingCountEventEvent", pingCountEventStructClass);
            if (err != CHIP_NO_ERROR)
            {
                ChipLogError(Zcl, "Could not find class ChipEventStructs$SampleMeiClusterPingCountEventEvent");
                return nullptr;
            }

            jmethodID pingCountEventStructCtor;
            err = chip::JniReferences::GetInstance().FindMethod(
                env, pingCountEventStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;)V", &pingCountEventStructCtor);
            if (err != CHIP_NO_ERROR || pingCountEventStructCtor == nullptr)
            {
                ChipLogError(Zcl, "Could not find ChipEventStructs$SampleMeiClusterPingCountEventEvent constructor");
                return nullptr;
            }

            jobject value = env->NewObject(pingCountEventStructClass, pingCountEventStructCtor, value_count, value_fabricIndex);

            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