src/controller/python/chip/clusters/CHIPClusters.cpp

/*
 *
 *    Copyright (c) 2021 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP

#include <app-common/zap-generated/cluster-objects.h>
#include <app/CommandSender.h>
#include <app/InteractionModelEngine.h>
#include <app/data-model/DecodableList.h>
#include <lib/core/CHIPCore.h>
#include <lib/support/Span.h>

#include <app/DeviceProxy.h>

#include <zap-generated/CHIPClientCallbacks.h>
#include <zap-generated/CHIPClusters.h>

using namespace chip;
using namespace chip::app;

namespace {

// Define pointers for external ZCL response delegates.

using SuccessResponseDelegate = void (*)();
using FailureResponseDelegate = void (*)(uint8_t);
SuccessResponseDelegate gSuccessResponseDelegate;
FailureResponseDelegate gFailureResponseDelegate;

// Define callbacks for ZCL commands and attribute requests.

#if CHIP_PROGRESS_LOGGING
std::string ByteSpanToString(chip::ByteSpan value)
{
    std::string strValue = "";
    for (size_t i = 0; i < value.size(); i++)
    {
        strValue += ' ';
        strValue += std::to_string(value.data()[i]);
    }
    return strValue;
}
#endif

void OnDefaultSuccessResponse(void * /* context */)
{
    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}

void OnDefaultFailureResponse(void * /* context */, uint8_t status)
{
    if (gFailureResponseDelegate != nullptr)
        gFailureResponseDelegate(status);
}

template <class AttributeType>
void OnAttributeResponse(void * /* context */, AttributeType value)
{
    std::string strValue = std::to_string(value);
    ChipLogProgress(Zcl, "  attributeValue: %s", strValue.c_str());
    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}

template <>
void OnAttributeResponse<chip::ByteSpan>(void * /* context */, chip::ByteSpan value)
{
    ChipLogProgress(Zcl, "  attributeValue: (span of length %zd) %s", value.size(), ByteSpanToString(value).c_str());
    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}

template <>
void OnAttributeResponse<chip::CharSpan>(void * /* context */, chip::CharSpan value)
{
    ChipLogProgress(Zcl, "  attributeValue: '%.*s'", static_cast<int>(value.size()), value.data());
    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}

template <>
void OnAttributeResponse<bool>(void * /* context */, bool value)
{
    ChipLogProgress(Zcl, "  attributeValue: %s", value ? "true" : "false");
    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}

static void
OnApplicationLauncherApplicationLauncherListListAttributeResponse(void * context,
                                                                  const chip::app::DataModel::DecodableList<uint16_t> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu16 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ApplicationLauncherApplicationLauncherListListAttributeCallback>
    gApplicationLauncherApplicationLauncherListListAttributeCallback{
        OnApplicationLauncherApplicationLauncherListListAttributeResponse, nullptr
    };
static void OnAudioOutputAudioOutputListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::AudioOutput::Structs::AudioOutputInfo::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      index: %" PRIu8 ",", entry.index);
        ChipLogProgress(Zcl, "      outputType: %" PRIu8 ",", entry.outputType);
        ChipLogProgress(Zcl, "      name: %.*s,", static_cast<int>(entry.name.size()), entry.name.data());
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<AudioOutputAudioOutputListListAttributeCallback> gAudioOutputAudioOutputListListAttributeCallback{
    OnAudioOutputAudioOutputListListAttributeResponse, nullptr
};
static void OnBridgedActionsActionListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::BridgedActions::Structs::ActionStruct::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      ActionID: %" PRIu16 ",", entry.actionID);
        ChipLogProgress(Zcl, "      Name: %.*s,", static_cast<int>(entry.name.size()), entry.name.data());
        ChipLogProgress(Zcl, "      Type: %" PRIu8 ",", entry.type);
        ChipLogProgress(Zcl, "      EndpointListID: %" PRIu16 ",", entry.endpointListID);
        ChipLogProgress(Zcl, "      SupportedCommands: %" PRIu16 ",", entry.supportedCommands);
        ChipLogProgress(Zcl, "      Status: %" PRIu8 ",", entry.status);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<BridgedActionsActionListListAttributeCallback> gBridgedActionsActionListListAttributeCallback{
    OnBridgedActionsActionListListAttributeResponse, nullptr
};
static void OnBridgedActionsEndpointListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::BridgedActions::Structs::EndpointListStruct::DecodableType> &
        list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      EndpointListID: %" PRIu16 ",", entry.endpointListID);
        ChipLogProgress(Zcl, "      Name: %.*s,", static_cast<int>(entry.name.size()), entry.name.data());
        ChipLogProgress(Zcl, "      Type: %" PRIu8 ",", entry.type);
        ChipLogProgress(Zcl, "      Endpoints: %s,", ByteSpanToString(entry.endpoints).c_str());
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<BridgedActionsEndpointListListAttributeCallback> gBridgedActionsEndpointListListAttributeCallback{
    OnBridgedActionsEndpointListListAttributeResponse, nullptr
};
static void
OnContentLauncherAcceptsHeaderListListAttributeResponse(void * context,
                                                        const chip::app::DataModel::DecodableList<chip::ByteSpan> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %s,", ByteSpanToString(entry).c_str());
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ContentLauncherAcceptsHeaderListListAttributeCallback>
    gContentLauncherAcceptsHeaderListListAttributeCallback{ OnContentLauncherAcceptsHeaderListListAttributeResponse, nullptr };
static void OnContentLauncherSupportedStreamingTypesListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::ContentLauncher::ContentLaunchStreamingType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu8 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ContentLauncherSupportedStreamingTypesListAttributeCallback>
    gContentLauncherSupportedStreamingTypesListAttributeCallback{ OnContentLauncherSupportedStreamingTypesListAttributeResponse,
                                                                  nullptr };
static void OnDescriptorDeviceListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::DeviceType::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      type: %" PRIu32 ",", entry.type);
        ChipLogProgress(Zcl, "      revision: %" PRIu16 ",", entry.revision);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<DescriptorDeviceListListAttributeCallback> gDescriptorDeviceListListAttributeCallback{
    OnDescriptorDeviceListListAttributeResponse, nullptr
};
static void OnDescriptorServerListListAttributeResponse(void * context,
                                                        const chip::app::DataModel::DecodableList<chip::ClusterId> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu32 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<DescriptorServerListListAttributeCallback> gDescriptorServerListListAttributeCallback{
    OnDescriptorServerListListAttributeResponse, nullptr
};
static void OnDescriptorClientListListAttributeResponse(void * context,
                                                        const chip::app::DataModel::DecodableList<chip::ClusterId> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu32 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<DescriptorClientListListAttributeCallback> gDescriptorClientListListAttributeCallback{
    OnDescriptorClientListListAttributeResponse, nullptr
};
static void OnDescriptorPartsListListAttributeResponse(void * context,
                                                       const chip::app::DataModel::DecodableList<chip::EndpointId> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu16 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<DescriptorPartsListListAttributeCallback> gDescriptorPartsListListAttributeCallback{
    OnDescriptorPartsListListAttributeResponse, nullptr
};
static void OnFixedLabelLabelListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::FixedLabel::Structs::LabelStruct::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      label: %.*s,", static_cast<int>(entry.label.size()), entry.label.data());
        ChipLogProgress(Zcl, "      value: %.*s,", static_cast<int>(entry.value.size()), entry.value.data());
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<FixedLabelLabelListListAttributeCallback> gFixedLabelLabelListListAttributeCallback{
    OnFixedLabelLabelListListAttributeResponse, nullptr
};
static void OnGeneralCommissioningBasicCommissioningInfoListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfoType::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      FailSafeExpiryLengthMs: %" PRIu32 ",", entry.failSafeExpiryLengthMs);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<GeneralCommissioningBasicCommissioningInfoListListAttributeCallback>
    gGeneralCommissioningBasicCommissioningInfoListListAttributeCallback{
        OnGeneralCommissioningBasicCommissioningInfoListListAttributeResponse, nullptr
    };
static void OnGeneralDiagnosticsNetworkInterfacesListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      Name: %.*s,", static_cast<int>(entry.name.size()), entry.name.data());
        ChipLogProgress(Zcl, "      FabricConnected: %d,", entry.fabricConnected);
        ChipLogProgress(Zcl, "      OffPremiseServicesReachableIPv4: %d,", entry.offPremiseServicesReachableIPv4);
        ChipLogProgress(Zcl, "      OffPremiseServicesReachableIPv6: %d,", entry.offPremiseServicesReachableIPv6);
        ChipLogProgress(Zcl, "      HardwareAddress: %s,", ByteSpanToString(entry.hardwareAddress).c_str());
        ChipLogProgress(Zcl, "      Type: %" PRIu8 ",", entry.type);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>
    gGeneralDiagnosticsNetworkInterfacesListAttributeCallback{ OnGeneralDiagnosticsNetworkInterfacesListAttributeResponse,
                                                               nullptr };
static void OnGeneralDiagnosticsActiveHardwareFaultsListAttributeResponse(void * context,
                                                                          const chip::app::DataModel::DecodableList<uint8_t> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu8 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>
    gGeneralDiagnosticsActiveHardwareFaultsListAttributeCallback{ OnGeneralDiagnosticsActiveHardwareFaultsListAttributeResponse,
                                                                  nullptr };
static void OnGeneralDiagnosticsActiveRadioFaultsListAttributeResponse(void * context,
                                                                       const chip::app::DataModel::DecodableList<uint8_t> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu8 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>
    gGeneralDiagnosticsActiveRadioFaultsListAttributeCallback{ OnGeneralDiagnosticsActiveRadioFaultsListAttributeResponse,
                                                               nullptr };
static void OnGeneralDiagnosticsActiveNetworkFaultsListAttributeResponse(void * context,
                                                                         const chip::app::DataModel::DecodableList<uint8_t> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu8 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>
    gGeneralDiagnosticsActiveNetworkFaultsListAttributeCallback{ OnGeneralDiagnosticsActiveNetworkFaultsListAttributeResponse,
                                                                 nullptr };
static void OnGroupKeyManagementGroupsListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::GroupKeyManagement::Structs::GroupState::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      VendorId: %" PRIu16 ",", entry.vendorId);
        ChipLogProgress(Zcl, "      VendorGroupId: %" PRIu16 ",", entry.vendorGroupId);
        ChipLogProgress(Zcl, "      GroupKeySetIndex: %" PRIu16 ",", entry.groupKeySetIndex);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<GroupKeyManagementGroupsListAttributeCallback> gGroupKeyManagementGroupsListAttributeCallback{
    OnGroupKeyManagementGroupsListAttributeResponse, nullptr
};
static void OnGroupKeyManagementGroupKeysListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::GroupKeyManagement::Structs::GroupKey::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      VendorId: %" PRIu16 ",", entry.vendorId);
        ChipLogProgress(Zcl, "      GroupKeyIndex: %" PRIu16 ",", entry.groupKeyIndex);
        ChipLogProgress(Zcl, "      GroupKeyRoot: %s,", ByteSpanToString(entry.groupKeyRoot).c_str());
        ChipLogProgress(Zcl, "      GroupKeyEpochStartTime: %" PRIu64 ",", entry.groupKeyEpochStartTime);
        ChipLogProgress(Zcl, "      GroupKeySecurityPolicy: %" PRIu8 ",", entry.groupKeySecurityPolicy);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<GroupKeyManagementGroupKeysListAttributeCallback> gGroupKeyManagementGroupKeysListAttributeCallback{
    OnGroupKeyManagementGroupKeysListAttributeResponse, nullptr
};
static void OnMediaInputMediaInputListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::MediaInput::Structs::MediaInputInfo::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      index: %" PRIu8 ",", entry.index);
        ChipLogProgress(Zcl, "      inputType: %" PRIu8 ",", entry.inputType);
        ChipLogProgress(Zcl, "      name: %.*s,", static_cast<int>(entry.name.size()), entry.name.data());
        ChipLogProgress(Zcl, "      description: %.*s,", static_cast<int>(entry.description.size()), entry.description.data());
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<MediaInputMediaInputListListAttributeCallback> gMediaInputMediaInputListListAttributeCallback{
    OnMediaInputMediaInputListListAttributeResponse, nullptr
};
static void OnModeSelectSupportedModesListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      Label: %.*s,", static_cast<int>(entry.label.size()), entry.label.data());
        ChipLogProgress(Zcl, "      Mode: %" PRIu8 ",", entry.mode);
        ChipLogProgress(Zcl, "      SemanticTag: %" PRIu32 ",", entry.semanticTag);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ModeSelectSupportedModesListAttributeCallback> gModeSelectSupportedModesListAttributeCallback{
    OnModeSelectSupportedModesListAttributeResponse, nullptr
};
static void OnOperationalCredentialsFabricsListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      FabricIndex: %" PRIu8 ",", entry.fabricIndex);
        ChipLogProgress(Zcl, "      RootPublicKey: %s,", ByteSpanToString(entry.rootPublicKey).c_str());
        ChipLogProgress(Zcl, "      VendorId: %" PRIu16 ",", entry.vendorId);
        ChipLogProgress(Zcl, "      FabricId: %" PRIu64 ",", entry.fabricId);
        ChipLogProgress(Zcl, "      NodeId: %" PRIu64 ",", entry.nodeId);
        ChipLogProgress(Zcl, "      Label: %.*s,", static_cast<int>(entry.label.size()), entry.label.data());
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<OperationalCredentialsFabricsListListAttributeCallback>
    gOperationalCredentialsFabricsListListAttributeCallback{ OnOperationalCredentialsFabricsListListAttributeResponse, nullptr };
static void OnOperationalCredentialsTrustedRootCertificatesListAttributeResponse(
    void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %s,", ByteSpanToString(entry).c_str());
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>
    gOperationalCredentialsTrustedRootCertificatesListAttributeCallback{
        OnOperationalCredentialsTrustedRootCertificatesListAttributeResponse, nullptr
    };
static void OnPowerSourceActiveBatteryFaultsListAttributeResponse(void * context,
                                                                  const chip::app::DataModel::DecodableList<uint8_t> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu8 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<PowerSourceActiveBatteryFaultsListAttributeCallback> gPowerSourceActiveBatteryFaultsListAttributeCallback{
    OnPowerSourceActiveBatteryFaultsListAttributeResponse, nullptr
};
static void OnSoftwareDiagnosticsThreadMetricsListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetrics::DecodableType> &
        list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      Id: %" PRIu64 ",", entry.id);
        ChipLogProgress(Zcl, "      Name: %.*s,", static_cast<int>(entry.name.size()), entry.name.data());
        ChipLogProgress(Zcl, "      StackFreeCurrent: %" PRIu32 ",", entry.stackFreeCurrent);
        ChipLogProgress(Zcl, "      StackFreeMinimum: %" PRIu32 ",", entry.stackFreeMinimum);
        ChipLogProgress(Zcl, "      StackSize: %" PRIu32 ",", entry.stackSize);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<SoftwareDiagnosticsThreadMetricsListAttributeCallback>
    gSoftwareDiagnosticsThreadMetricsListAttributeCallback{ OnSoftwareDiagnosticsThreadMetricsListAttributeResponse, nullptr };
static void OnTvChannelTvChannelListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::TvChannel::Structs::TvChannelInfo::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      majorNumber: %" PRIu16 ",", entry.majorNumber);
        ChipLogProgress(Zcl, "      minorNumber: %" PRIu16 ",", entry.minorNumber);
        ChipLogProgress(Zcl, "      name: %.*s,", static_cast<int>(entry.name.size()), entry.name.data());
        ChipLogProgress(Zcl, "      callSign: %.*s,", static_cast<int>(entry.callSign.size()), entry.callSign.data());
        ChipLogProgress(Zcl, "      affiliateCallSign: %.*s,", static_cast<int>(entry.affiliateCallSign.size()),
                        entry.affiliateCallSign.data());
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<TvChannelTvChannelListListAttributeCallback> gTvChannelTvChannelListListAttributeCallback{
    OnTvChannelTvChannelListListAttributeResponse, nullptr
};
static void OnTargetNavigatorTargetNavigatorListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::TargetNavigator::Structs::NavigateTargetTargetInfo::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      identifier: %" PRIu8 ",", entry.identifier);
        ChipLogProgress(Zcl, "      name: %.*s,", static_cast<int>(entry.name.size()), entry.name.data());
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<TargetNavigatorTargetNavigatorListListAttributeCallback>
    gTargetNavigatorTargetNavigatorListListAttributeCallback{ OnTargetNavigatorTargetNavigatorListListAttributeResponse, nullptr };
static void OnTestClusterListInt8uListAttributeResponse(void * context, const chip::app::DataModel::DecodableList<uint8_t> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu8 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<TestClusterListInt8uListAttributeCallback> gTestClusterListInt8uListAttributeCallback{
    OnTestClusterListInt8uListAttributeResponse, nullptr
};
static void OnTestClusterListOctetStringListAttributeResponse(void * context,
                                                              const chip::app::DataModel::DecodableList<chip::ByteSpan> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %s,", ByteSpanToString(entry).c_str());
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<TestClusterListOctetStringListAttributeCallback> gTestClusterListOctetStringListAttributeCallback{
    OnTestClusterListOctetStringListAttributeResponse, nullptr
};
static void OnTestClusterListStructOctetStringListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      fabricIndex: %" PRIu64 ",", entry.fabricIndex);
        ChipLogProgress(Zcl, "      operationalCert: %s,", ByteSpanToString(entry.operationalCert).c_str());
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<TestClusterListStructOctetStringListAttributeCallback>
    gTestClusterListStructOctetStringListAttributeCallback{ OnTestClusterListStructOctetStringListAttributeResponse, nullptr };
static void OnTestClusterListNullablesAndOptionalsStructListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        if (entry.nullableInt.IsNull())
        {
            ChipLogProgress(chipTool, "  NullableInt: null");
        }
        else
        {
            ChipLogProgress(Zcl, "      NullableInt: %" PRIu16 ",", entry.nullableInt.Value());
        }
        if (entry.optionalInt.HasValue())
        {
            ChipLogProgress(Zcl, "      OptionalInt: %" PRIu16 ",", entry.optionalInt.Value());
        }
        if (entry.nullableOptionalInt.HasValue())
        {
            if (entry.nullableOptionalInt.Value().IsNull())
            {
                ChipLogProgress(chipTool, "  NullableOptionalInt: null");
            }
            else
            {
                ChipLogProgress(Zcl, "      NullableOptionalInt: %" PRIu16 ",", entry.nullableOptionalInt.Value().Value());
            }
        }
        if (entry.nullableString.IsNull())
        {
            ChipLogProgress(chipTool, "  NullableString: null");
        }
        else
        {
            ChipLogProgress(Zcl, "      NullableString: %.*s,", static_cast<int>(entry.nullableString.Value().size()),
                            entry.nullableString.Value().data());
        }
        if (entry.optionalString.HasValue())
        {
            ChipLogProgress(Zcl, "      OptionalString: %.*s,", static_cast<int>(entry.optionalString.Value().size()),
                            entry.optionalString.Value().data());
        }
        if (entry.nullableOptionalString.HasValue())
        {
            if (entry.nullableOptionalString.Value().IsNull())
            {
                ChipLogProgress(chipTool, "  NullableOptionalString: null");
            }
            else
            {
                ChipLogProgress(Zcl, "      NullableOptionalString: %.*s,",
                                static_cast<int>(entry.nullableOptionalString.Value().Value().size()),
                                entry.nullableOptionalString.Value().Value().data());
            }
        }
        if (entry.nullableStruct.IsNull())
        {
            ChipLogProgress(chipTool, "  NullableStruct: null");
        }
        else
        {
            ChipLogProgress(chipTool,
                            "  NullableStruct: struct member of struct element of list attribute printing not supported yet");
        }
        if (entry.optionalStruct.HasValue())
        {
            ChipLogProgress(chipTool,
                            "  OptionalStruct: struct member of struct element of list attribute printing not supported yet");
        }
        if (entry.nullableOptionalStruct.HasValue())
        {
            if (entry.nullableOptionalStruct.Value().IsNull())
            {
                ChipLogProgress(chipTool, "  NullableOptionalStruct: null");
            }
            else
            {
                ChipLogProgress(
                    chipTool,
                    "  NullableOptionalStruct: struct member of struct element of list attribute printing not supported yet");
            }
        }
        if (entry.nullableList.IsNull())
        {
            ChipLogProgress(chipTool, "  NullableList: null");
        }
        else
        {
            ChipLogProgress(chipTool, "  NullableList: list member of struct element of list attribute printing not supported yet");
        }
        if (entry.optionalList.HasValue())
        {
            ChipLogProgress(chipTool, "  OptionalList: list member of struct element of list attribute printing not supported yet");
        }
        if (entry.nullableOptionalList.HasValue())
        {
            if (entry.nullableOptionalList.Value().IsNull())
            {
                ChipLogProgress(chipTool, "  NullableOptionalList: null");
            }
            else
            {
                ChipLogProgress(
                    chipTool, "  NullableOptionalList: list member of struct element of list attribute printing not supported yet");
            }
        }
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<TestClusterListNullablesAndOptionalsStructListAttributeCallback>
    gTestClusterListNullablesAndOptionalsStructListAttributeCallback{
        OnTestClusterListNullablesAndOptionalsStructListAttributeResponse, nullptr
    };
static void OnThreadNetworkDiagnosticsNeighborTableListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      ExtAddress: %" PRIu64 ",", entry.extAddress);
        ChipLogProgress(Zcl, "      Age: %" PRIu32 ",", entry.age);
        ChipLogProgress(Zcl, "      Rloc16: %" PRIu16 ",", entry.rloc16);
        ChipLogProgress(Zcl, "      LinkFrameCounter: %" PRIu32 ",", entry.linkFrameCounter);
        ChipLogProgress(Zcl, "      MleFrameCounter: %" PRIu32 ",", entry.mleFrameCounter);
        ChipLogProgress(Zcl, "      LQI: %" PRIu8 ",", entry.lqi);
        ChipLogProgress(Zcl, "      AverageRssi: %" PRId8 ",", entry.averageRssi);
        ChipLogProgress(Zcl, "      LastRssi: %" PRId8 ",", entry.lastRssi);
        ChipLogProgress(Zcl, "      FrameErrorRate: %" PRIu8 ",", entry.frameErrorRate);
        ChipLogProgress(Zcl, "      MessageErrorRate: %" PRIu8 ",", entry.messageErrorRate);
        ChipLogProgress(Zcl, "      RxOnWhenIdle: %d,", entry.rxOnWhenIdle);
        ChipLogProgress(Zcl, "      FullThreadDevice: %d,", entry.fullThreadDevice);
        ChipLogProgress(Zcl, "      FullNetworkData: %d,", entry.fullNetworkData);
        ChipLogProgress(Zcl, "      IsChild: %d,", entry.isChild);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>
    gThreadNetworkDiagnosticsNeighborTableListListAttributeCallback{
        OnThreadNetworkDiagnosticsNeighborTableListListAttributeResponse, nullptr
    };
static void OnThreadNetworkDiagnosticsRouteTableListListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::DecodableType> &
        list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      ExtAddress: %" PRIu64 ",", entry.extAddress);
        ChipLogProgress(Zcl, "      Rloc16: %" PRIu16 ",", entry.rloc16);
        ChipLogProgress(Zcl, "      RouterId: %" PRIu8 ",", entry.routerId);
        ChipLogProgress(Zcl, "      NextHop: %" PRIu8 ",", entry.nextHop);
        ChipLogProgress(Zcl, "      PathCost: %" PRIu8 ",", entry.pathCost);
        ChipLogProgress(Zcl, "      LQIIn: %" PRIu8 ",", entry.LQIIn);
        ChipLogProgress(Zcl, "      LQIOut: %" PRIu8 ",", entry.LQIOut);
        ChipLogProgress(Zcl, "      Age: %" PRIu8 ",", entry.age);
        ChipLogProgress(Zcl, "      Allocated: %d,", entry.allocated);
        ChipLogProgress(Zcl, "      LinkEstablished: %d,", entry.linkEstablished);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>
    gThreadNetworkDiagnosticsRouteTableListListAttributeCallback{ OnThreadNetworkDiagnosticsRouteTableListListAttributeResponse,
                                                                  nullptr };
static void OnThreadNetworkDiagnosticsSecurityPolicyListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      RotationTime: %" PRIu16 ",", entry.rotationTime);
        ChipLogProgress(Zcl, "      Flags: %" PRIu16 ",", entry.flags);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ThreadNetworkDiagnosticsSecurityPolicyListAttributeCallback>
    gThreadNetworkDiagnosticsSecurityPolicyListAttributeCallback{ OnThreadNetworkDiagnosticsSecurityPolicyListAttributeResponse,
                                                                  nullptr };
static void OnThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeResponse(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    {");
        ChipLogProgress(Zcl, "      ActiveTimestampPresent: %d,", entry.activeTimestampPresent);
        ChipLogProgress(Zcl, "      PendingTimestampPresent: %d,", entry.pendingTimestampPresent);
        ChipLogProgress(Zcl, "      MasterKeyPresent: %d,", entry.masterKeyPresent);
        ChipLogProgress(Zcl, "      NetworkNamePresent: %d,", entry.networkNamePresent);
        ChipLogProgress(Zcl, "      ExtendedPanIdPresent: %d,", entry.extendedPanIdPresent);
        ChipLogProgress(Zcl, "      MeshLocalPrefixPresent: %d,", entry.meshLocalPrefixPresent);
        ChipLogProgress(Zcl, "      DelayPresent: %d,", entry.delayPresent);
        ChipLogProgress(Zcl, "      PanIdPresent: %d,", entry.panIdPresent);
        ChipLogProgress(Zcl, "      ChannelPresent: %d,", entry.channelPresent);
        ChipLogProgress(Zcl, "      PskcPresent: %d,", entry.pskcPresent);
        ChipLogProgress(Zcl, "      SecurityPolicyPresent: %d,", entry.securityPolicyPresent);
        ChipLogProgress(Zcl, "      ChannelMaskPresent: %d,", entry.channelMaskPresent);
        ChipLogProgress(Zcl, "    },");
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallback>
    gThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallback{
        OnThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeResponse, nullptr
    };
static void OnThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeResponse(
    void * context, const chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault> & list)
{
    size_t count   = 0;
    CHIP_ERROR err = list.ComputeSize(&count);
    if (err != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    ChipLogProgress(Zcl, "  attributeValue:%s", count > 0 ? "" : " []");

    if (count > 0)
        ChipLogProgress(Zcl, "  [");

    auto iter = list.begin();
    while (iter.Next())
    {
#if CHIP_PROGRESS_LOGGING
        auto & entry = iter.GetValue();
        ChipLogProgress(Zcl, "    %" PRIu8 ",", entry);
#endif // CHIP_PROGRESS_LOGGING
    }
    if (iter.GetStatus() != CHIP_NO_ERROR)
    {
        if (gFailureResponseDelegate != nullptr)
        {
            gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
        }
        return;
    }

    if (count > 0)
        ChipLogProgress(Zcl, "  ]");

    if (gSuccessResponseDelegate != nullptr)
        gSuccessResponseDelegate();
}
chip::Callback::Callback<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>
    gThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback{
        OnThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeResponse, nullptr
    };

chip::Callback::Callback<DefaultSuccessCallback> gDefaultSuccessCallback{ OnDefaultSuccessResponse, nullptr };
chip::Callback::Callback<DefaultFailureCallback> gDefaultFailureCallback{ OnDefaultFailureResponse, nullptr };
chip::Callback::Callback<BooleanAttributeCallback> gBooleanAttributeCallback{ OnAttributeResponse<bool>, nullptr };
chip::Callback::Callback<Int8uAttributeCallback> gInt8uAttributeCallback{ OnAttributeResponse<uint8_t>, nullptr };
chip::Callback::Callback<Int8sAttributeCallback> gInt8sAttributeCallback{ OnAttributeResponse<int8_t>, nullptr };
chip::Callback::Callback<Int16uAttributeCallback> gInt16uAttributeCallback{ OnAttributeResponse<uint16_t>, nullptr };
chip::Callback::Callback<Int16sAttributeCallback> gInt16sAttributeCallback{ OnAttributeResponse<int16_t>, nullptr };
chip::Callback::Callback<Int32uAttributeCallback> gInt32uAttributeCallback{ OnAttributeResponse<uint32_t>, nullptr };
chip::Callback::Callback<Int32sAttributeCallback> gInt32sAttributeCallback{ OnAttributeResponse<int32_t>, nullptr };
chip::Callback::Callback<Int64uAttributeCallback> gInt64uAttributeCallback{ OnAttributeResponse<uint64_t>, nullptr };
chip::Callback::Callback<Int64sAttributeCallback> gInt64sAttributeCallback{ OnAttributeResponse<int64_t>, nullptr };
chip::Callback::Callback<OctetStringAttributeCallback> gOctetStringAttributeCallback{ OnAttributeResponse<ByteSpan>, nullptr };
chip::Callback::Callback<CharStringAttributeCallback> gCharStringAttributeCallback{ OnAttributeResponse<CharSpan>, nullptr };

} // namespace

extern "C" {

void chip_ime_SetSuccessResponseDelegate(SuccessResponseDelegate delegate)
{
    gSuccessResponseDelegate = delegate;
}

void chip_ime_SetFailureResponseDelegate(FailureResponseDelegate delegate)
{
    gFailureResponseDelegate = delegate;
}

// Cluster AccountLogin

chip::ChipError::StorageType chip_ime_ReadAttribute_AccountLogin_ClusterRevision(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::AccountLoginCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster AccountLogin
// Cluster AdministratorCommissioning

chip::ChipError::StorageType chip_ime_ReadAttribute_AdministratorCommissioning_ClusterRevision(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::AdministratorCommissioningCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster AdministratorCommissioning
// Cluster ApplicationBasic

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationBasic_VendorName(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeVendorName(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationBasic_VendorId(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeVendorId(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationBasic_ApplicationName(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeApplicationName(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationBasic_ProductId(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeProductId(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationBasic_ApplicationId(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeApplicationId(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationBasic_CatalogVendorId(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCatalogVendorId(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationBasic_ApplicationStatus(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeApplicationStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationBasic_ClusterRevision(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster ApplicationBasic
// Cluster ApplicationLauncher

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationLauncher_ApplicationLauncherList(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationLauncherCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeApplicationLauncherList(gApplicationLauncherApplicationLauncherListListAttributeCallback.Cancel(),
                                              gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationLauncher_CatalogVendorId(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationLauncherCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCatalogVendorId(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationLauncher_ApplicationId(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationLauncherCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeApplicationId(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ApplicationLauncher_ClusterRevision(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ApplicationLauncherCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster ApplicationLauncher
// Cluster AudioOutput

chip::ChipError::StorageType chip_ime_ReadAttribute_AudioOutput_AudioOutputList(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::AudioOutputCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeAudioOutputList(gAudioOutputAudioOutputListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_AudioOutput_CurrentAudioOutput(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::AudioOutputCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentAudioOutput(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_AudioOutput_ClusterRevision(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::AudioOutputCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster AudioOutput
// Cluster BarrierControl

chip::ChipError::StorageType chip_ime_ReadAttribute_BarrierControl_BarrierMovingState(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BarrierControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBarrierMovingState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BarrierControl_BarrierSafetyStatus(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BarrierControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBarrierSafetyStatus(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BarrierControl_BarrierCapabilities(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BarrierControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBarrierCapabilities(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BarrierControl_BarrierPosition(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BarrierControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBarrierPosition(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BarrierControl_ClusterRevision(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BarrierControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster BarrierControl
// Cluster Basic

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_InteractionModelVersion(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInteractionModelVersion(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_VendorName(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeVendorName(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_VendorID(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeVendorID(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_ProductName(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeProductName(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_ProductID(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeProductID(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_UserLabel(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeUserLabel(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_Location(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLocation(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_HardwareVersion(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeHardwareVersion(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_HardwareVersionString(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeHardwareVersionString(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_SoftwareVersion(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSoftwareVersion(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_SoftwareVersionString(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSoftwareVersionString(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_ManufacturingDate(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeManufacturingDate(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_PartNumber(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePartNumber(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_ProductURL(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeProductURL(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_ProductLabel(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeProductLabel(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_SerialNumber(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSerialNumber(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_LocalConfigDisabled(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLocalConfigDisabled(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_Reachable(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeReachable(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Basic_ClusterRevision(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster Basic
// Cluster BinaryInputBasic

chip::ChipError::StorageType chip_ime_ReadAttribute_BinaryInputBasic_OutOfService(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BinaryInputBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOutOfService(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BinaryInputBasic_PresentValue(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BinaryInputBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePresentValue(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_BinaryInputBasic_PresentValue(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BinaryInputBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributePresentValue(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                        maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BinaryInputBasic_StatusFlags(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BinaryInputBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStatusFlags(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_BinaryInputBasic_StatusFlags(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BinaryInputBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeStatusFlags(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BinaryInputBasic_ClusterRevision(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BinaryInputBasicCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster BinaryInputBasic
// Cluster Binding

chip::ChipError::StorageType chip_ime_ReadAttribute_Binding_ClusterRevision(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BindingCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster Binding
// Cluster BooleanState

chip::ChipError::StorageType chip_ime_ReadAttribute_BooleanState_StateValue(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BooleanStateCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStateValue(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_BooleanState_StateValue(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BooleanStateCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeStateValue(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                      maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BooleanState_ClusterRevision(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BooleanStateCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster BooleanState
// Cluster BridgedActions

chip::ChipError::StorageType chip_ime_ReadAttribute_BridgedActions_ActionList(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BridgedActionsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeActionList(gBridgedActionsActionListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BridgedActions_EndpointList(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BridgedActionsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeEndpointList(gBridgedActionsEndpointListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BridgedActions_SetupUrl(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BridgedActionsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSetupUrl(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_BridgedActions_ClusterRevision(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BridgedActionsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster BridgedActions
// Cluster BridgedDeviceBasicInformation

chip::ChipError::StorageType chip_ime_ReadAttribute_BridgedDeviceBasicInformation_ClusterRevision(chip::DeviceProxy * device,
                                                                                                  chip::EndpointId ZCLendpointId,
                                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::BridgedDeviceBasicInformationCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster BridgedDeviceBasicInformation
// Cluster ColorControl

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CurrentHue(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentHue(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_CurrentHue(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentHue(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CurrentSaturation(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentSaturation(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_CurrentSaturation(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentSaturation(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                             maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_RemainingTime(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRemainingTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CurrentX(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_CurrentX(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId, uint16_t minInterval,
                                                                               uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CurrentY(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_CurrentY(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId, uint16_t minInterval,
                                                                               uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_DriftCompensation(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDriftCompensation(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CompensationText(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCompensationText(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorTemperature(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorTemperature(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_ColorTemperature(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeColorTemperature(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                            maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorMode(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorControlOptions(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorControlOptions(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_NumberOfPrimaries(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNumberOfPrimaries(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary1X(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary1X(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary1Y(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary1Y(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary1Intensity(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary1Intensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary2X(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary2X(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary2Y(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary2Y(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary2Intensity(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary2Intensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary3X(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary3X(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary3Y(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary3Y(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary3Intensity(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary3Intensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary4X(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary4X(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary4Y(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary4Y(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary4Intensity(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary4Intensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary5X(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary5X(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary5Y(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary5Y(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary5Intensity(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary5Intensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary6X(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary6X(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary6Y(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary6Y(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_Primary6Intensity(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePrimary6Intensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_WhitePointX(chip::DeviceProxy * device,
                                                                             chip::EndpointId ZCLendpointId,
                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeWhitePointX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_WhitePointY(chip::DeviceProxy * device,
                                                                             chip::EndpointId ZCLendpointId,
                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeWhitePointY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointRX(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointRX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointRY(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointRY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointRIntensity(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointRIntensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointGX(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointGX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointGY(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointGY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointGIntensity(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointGIntensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointBX(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointBX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointBY(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointBY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorPointBIntensity(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorPointBIntensity(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_EnhancedCurrentHue(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEnhancedCurrentHue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_EnhancedColorMode(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEnhancedColorMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorLoopActive(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorLoopActive(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorLoopDirection(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorLoopDirection(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorLoopTime(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorLoopTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorLoopStartEnhancedHue(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorLoopStartEnhancedHue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorLoopStoredEnhancedHue(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorLoopStoredEnhancedHue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorCapabilities(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorCapabilities(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorTempPhysicalMin(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorTempPhysicalMin(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorTempPhysicalMax(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeColorTempPhysicalMax(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CoupleColorTempToLevelMinMireds(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCoupleColorTempToLevelMinMireds(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_StartUpColorTemperatureMireds(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStartUpColorTemperatureMireds(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ClusterRevision(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ColorControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster ColorControl
// Cluster ContentLauncher

chip::ChipError::StorageType chip_ime_ReadAttribute_ContentLauncher_AcceptsHeaderList(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ContentLauncherCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeAcceptsHeaderList(gContentLauncherAcceptsHeaderListListAttributeCallback.Cancel(),
                                        gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ContentLauncher_SupportedStreamingTypes(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ContentLauncherCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeSupportedStreamingTypes(gContentLauncherSupportedStreamingTypesListAttributeCallback.Cancel(),
                                              gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ContentLauncher_ClusterRevision(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ContentLauncherCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster ContentLauncher
// Cluster Descriptor

chip::ChipError::StorageType chip_ime_ReadAttribute_Descriptor_DeviceList(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DescriptorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDeviceList(gDescriptorDeviceListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Descriptor_ServerList(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DescriptorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeServerList(gDescriptorServerListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Descriptor_ClientList(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DescriptorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClientList(gDescriptorClientListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Descriptor_PartsList(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DescriptorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePartsList(gDescriptorPartsListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Descriptor_ClusterRevision(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DescriptorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster Descriptor
// Cluster DiagnosticLogs

// End of Cluster DiagnosticLogs
// Cluster DoorLock

chip::ChipError::StorageType chip_ime_ReadAttribute_DoorLock_LockState(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DoorLockCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLockState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_DoorLock_LockState(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId, uint16_t minInterval,
                                                                            uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DoorLockCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeLockState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_DoorLock_LockType(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DoorLockCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLockType(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_DoorLock_ActuatorEnabled(chip::DeviceProxy * device,
                                                                             chip::EndpointId ZCLendpointId,
                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DoorLockCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeActuatorEnabled(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_DoorLock_ClusterRevision(chip::DeviceProxy * device,
                                                                             chip::EndpointId ZCLendpointId,
                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::DoorLockCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster DoorLock
// Cluster ElectricalMeasurement

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_MeasurementType(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMeasurementType(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_TotalActivePower(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTotalActivePower(gInt32sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_RmsVoltage(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRmsVoltage(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_RmsVoltageMin(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRmsVoltageMin(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_RmsVoltageMax(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRmsVoltageMax(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_RmsCurrent(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRmsCurrent(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_RmsCurrentMin(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRmsCurrentMin(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_RmsCurrentMax(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRmsCurrentMax(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_ActivePower(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeActivePower(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_ActivePowerMin(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeActivePowerMin(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_ActivePowerMax(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeActivePowerMax(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ElectricalMeasurement_ClusterRevision(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ElectricalMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster ElectricalMeasurement
// Cluster EthernetNetworkDiagnostics

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_PHYRate(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePHYRate(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_FullDuplex(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeFullDuplex(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_PacketRxCount(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePacketRxCount(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_PacketTxCount(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePacketTxCount(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_TxErrCount(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxErrCount(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_CollisionCount(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCollisionCount(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_OverrunCount(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOverrunCount(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_CarrierDetect(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCarrierDetect(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_TimeSinceReset(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTimeSinceReset(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_EthernetNetworkDiagnostics_ClusterRevision(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::EthernetNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster EthernetNetworkDiagnostics
// Cluster FixedLabel

chip::ChipError::StorageType chip_ime_ReadAttribute_FixedLabel_LabelList(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::FixedLabelCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLabelList(gFixedLabelLabelListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_FixedLabel_ClusterRevision(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::FixedLabelCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster FixedLabel
// Cluster FlowMeasurement

chip::ChipError::StorageType chip_ime_ReadAttribute_FlowMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::FlowMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_FlowMeasurement_MinMeasuredValue(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::FlowMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_FlowMeasurement_MaxMeasuredValue(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::FlowMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_FlowMeasurement_Tolerance(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::FlowMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTolerance(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_FlowMeasurement_ClusterRevision(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::FlowMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster FlowMeasurement
// Cluster GeneralCommissioning

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralCommissioning_Breadcrumb(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralCommissioningCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBreadcrumb(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralCommissioning_BasicCommissioningInfoList(chip::DeviceProxy * device,
                                                                                                    chip::EndpointId ZCLendpointId,
                                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralCommissioningCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeBasicCommissioningInfoList(gGeneralCommissioningBasicCommissioningInfoListListAttributeCallback.Cancel(),
                                                 gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralCommissioning_ClusterRevision(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralCommissioningCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster GeneralCommissioning
// Cluster GeneralDiagnostics

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_NetworkInterfaces(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeNetworkInterfaces(gGeneralDiagnosticsNetworkInterfacesListAttributeCallback.Cancel(),
                                        gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_RebootCount(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRebootCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_UpTime(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeUpTime(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_TotalOperationalHours(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTotalOperationalHours(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_BootReasons(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBootReasons(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_ActiveHardwareFaults(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeActiveHardwareFaults(gGeneralDiagnosticsActiveHardwareFaultsListAttributeCallback.Cancel(),
                                           gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_ActiveRadioFaults(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeActiveRadioFaults(gGeneralDiagnosticsActiveRadioFaultsListAttributeCallback.Cancel(),
                                        gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_ActiveNetworkFaults(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeActiveNetworkFaults(gGeneralDiagnosticsActiveNetworkFaultsListAttributeCallback.Cancel(),
                                          gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_ClusterRevision(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GeneralDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster GeneralDiagnostics
// Cluster GroupKeyManagement

chip::ChipError::StorageType chip_ime_ReadAttribute_GroupKeyManagement_Groups(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GroupKeyManagementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeGroups(gGroupKeyManagementGroupsListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GroupKeyManagement_GroupKeys(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GroupKeyManagementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeGroupKeys(gGroupKeyManagementGroupKeysListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_GroupKeyManagement_ClusterRevision(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GroupKeyManagementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster GroupKeyManagement
// Cluster Groups

chip::ChipError::StorageType chip_ime_ReadAttribute_Groups_NameSupport(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GroupsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNameSupport(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Groups_ClusterRevision(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::GroupsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster Groups
// Cluster Identify

chip::ChipError::StorageType chip_ime_ReadAttribute_Identify_IdentifyTime(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IdentifyCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeIdentifyTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Identify_IdentifyType(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IdentifyCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeIdentifyType(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Identify_ClusterRevision(chip::DeviceProxy * device,
                                                                             chip::EndpointId ZCLendpointId,
                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IdentifyCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster Identify
// Cluster IlluminanceMeasurement

chip::ChipError::StorageType chip_ime_ReadAttribute_IlluminanceMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IlluminanceMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_IlluminanceMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              uint16_t minInterval,
                                                                                              uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IlluminanceMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                         maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_IlluminanceMeasurement_MinMeasuredValue(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IlluminanceMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_IlluminanceMeasurement_MaxMeasuredValue(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IlluminanceMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_IlluminanceMeasurement_Tolerance(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IlluminanceMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTolerance(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_IlluminanceMeasurement_LightSensorType(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IlluminanceMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLightSensorType(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_IlluminanceMeasurement_ClusterRevision(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::IlluminanceMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster IlluminanceMeasurement
// Cluster KeypadInput

chip::ChipError::StorageType chip_ime_ReadAttribute_KeypadInput_ClusterRevision(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::KeypadInputCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster KeypadInput
// Cluster LevelControl

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_CurrentLevel(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_LevelControl_CurrentLevel(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                        maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_RemainingTime(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRemainingTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_MinLevel(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_MaxLevel(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_CurrentFrequency(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentFrequency(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_MinFrequency(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinFrequency(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_MaxFrequency(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxFrequency(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_Options(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOptions(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_OnOffTransitionTime(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOnOffTransitionTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_OnLevel(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOnLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_OnTransitionTime(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOnTransitionTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_OffTransitionTime(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOffTransitionTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_DefaultMoveRate(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDefaultMoveRate(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_StartUpCurrentLevel(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStartUpCurrentLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_ClusterRevision(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LevelControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster LevelControl
// Cluster LowPower

chip::ChipError::StorageType chip_ime_ReadAttribute_LowPower_ClusterRevision(chip::DeviceProxy * device,
                                                                             chip::EndpointId ZCLendpointId,
                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::LowPowerCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster LowPower
// Cluster MediaInput

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaInput_MediaInputList(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaInputCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeMediaInputList(gMediaInputMediaInputListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaInput_CurrentMediaInput(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaInputCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentMediaInput(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaInput_ClusterRevision(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaInputCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster MediaInput
// Cluster MediaPlayback

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_PlaybackState(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePlaybackState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_StartTime(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStartTime(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_Duration(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDuration(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_PositionUpdatedAt(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePositionUpdatedAt(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_Position(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePosition(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_PlaybackSpeed(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePlaybackSpeed(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_SeekRangeEnd(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSeekRangeEnd(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_SeekRangeStart(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSeekRangeStart(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_ClusterRevision(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::MediaPlaybackCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster MediaPlayback
// Cluster ModeSelect

chip::ChipError::StorageType chip_ime_ReadAttribute_ModeSelect_CurrentMode(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ModeSelectCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_ModeSelect_CurrentMode(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ModeSelectCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ModeSelect_SupportedModes(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ModeSelectCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeSupportedModes(gModeSelectSupportedModesListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ModeSelect_OnMode(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ModeSelectCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOnMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ModeSelect_StartUpMode(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ModeSelectCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStartUpMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ModeSelect_Description(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ModeSelectCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDescription(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ModeSelect_ClusterRevision(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ModeSelectCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster ModeSelect
// Cluster NetworkCommissioning

chip::ChipError::StorageType chip_ime_ReadAttribute_NetworkCommissioning_FeatureMap(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::NetworkCommissioningCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeFeatureMap(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_NetworkCommissioning_ClusterRevision(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::NetworkCommissioningCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster NetworkCommissioning
// Cluster OtaSoftwareUpdateProvider

chip::ChipError::StorageType chip_ime_ReadAttribute_OtaSoftwareUpdateProvider_ClusterRevision(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OtaSoftwareUpdateProviderCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster OtaSoftwareUpdateProvider
// Cluster OtaSoftwareUpdateRequestor

chip::ChipError::StorageType chip_ime_ReadAttribute_OtaSoftwareUpdateRequestor_DefaultOtaProvider(chip::DeviceProxy * device,
                                                                                                  chip::EndpointId ZCLendpointId,
                                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OtaSoftwareUpdateRequestorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDefaultOtaProvider(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OtaSoftwareUpdateRequestor_UpdatePossible(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OtaSoftwareUpdateRequestorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeUpdatePossible(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OtaSoftwareUpdateRequestor_ClusterRevision(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OtaSoftwareUpdateRequestorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster OtaSoftwareUpdateRequestor
// Cluster OccupancySensing

chip::ChipError::StorageType chip_ime_ReadAttribute_OccupancySensing_Occupancy(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OccupancySensingCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOccupancy(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_OccupancySensing_Occupancy(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OccupancySensingCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeOccupancy(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OccupancySensing_OccupancySensorType(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OccupancySensingCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOccupancySensorType(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OccupancySensing_OccupancySensorTypeBitmap(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OccupancySensingCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOccupancySensorTypeBitmap(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OccupancySensing_ClusterRevision(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OccupancySensingCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster OccupancySensing
// Cluster OnOff

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOff_OnOff(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOnOff(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_OnOff_OnOff(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                     uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeOnOff(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOff_GlobalSceneControl(chip::DeviceProxy * device,
                                                                             chip::EndpointId ZCLendpointId,
                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeGlobalSceneControl(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOff_OnTime(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOnTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOff_OffWaitTime(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOffWaitTime(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOff_StartUpOnOff(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStartUpOnOff(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOff_FeatureMap(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeFeatureMap(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOff_ClusterRevision(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster OnOff
// Cluster OnOffSwitchConfiguration

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOffSwitchConfiguration_SwitchType(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffSwitchConfigurationCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSwitchType(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOffSwitchConfiguration_SwitchActions(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffSwitchConfigurationCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSwitchActions(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OnOffSwitchConfiguration_ClusterRevision(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OnOffSwitchConfigurationCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster OnOffSwitchConfiguration
// Cluster OperationalCredentials

chip::ChipError::StorageType chip_ime_ReadAttribute_OperationalCredentials_FabricsList(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OperationalCredentialsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeFabricsList(gOperationalCredentialsFabricsListListAttributeCallback.Cancel(),
                                  gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OperationalCredentials_SupportedFabrics(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OperationalCredentialsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSupportedFabrics(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OperationalCredentials_CommissionedFabrics(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OperationalCredentialsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCommissionedFabrics(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OperationalCredentials_TrustedRootCertificates(chip::DeviceProxy * device,
                                                                                                   chip::EndpointId ZCLendpointId,
                                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OperationalCredentialsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeTrustedRootCertificates(gOperationalCredentialsTrustedRootCertificatesListAttributeCallback.Cancel(),
                                              gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OperationalCredentials_CurrentFabricIndex(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OperationalCredentialsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentFabricIndex(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_OperationalCredentials_ClusterRevision(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::OperationalCredentialsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster OperationalCredentials
// Cluster PowerSource

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_Status(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_Order(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOrder(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_Description(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDescription(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_BatteryVoltage(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBatteryVoltage(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_BatteryPercentRemaining(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBatteryPercentRemaining(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_BatteryTimeRemaining(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBatteryTimeRemaining(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_BatteryChargeLevel(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBatteryChargeLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_ActiveBatteryFaults(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeActiveBatteryFaults(gPowerSourceActiveBatteryFaultsListAttributeCallback.Cancel(),
                                          gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_BatteryChargeState(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBatteryChargeState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_FeatureMap(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeFeatureMap(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PowerSource_ClusterRevision(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PowerSourceCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster PowerSource
// Cluster PressureMeasurement

chip::ChipError::StorageType chip_ime_ReadAttribute_PressureMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PressureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_PressureMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           uint16_t minInterval,
                                                                                           uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PressureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                         maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PressureMeasurement_MinMeasuredValue(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PressureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PressureMeasurement_MaxMeasuredValue(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PressureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PressureMeasurement_ClusterRevision(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PressureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster PressureMeasurement
// Cluster PumpConfigurationAndControl

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MaxPressure(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxPressure(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MaxSpeed(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxSpeed(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MaxFlow(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxFlow(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MinConstPressure(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinConstPressure(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MaxConstPressure(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxConstPressure(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MinCompPressure(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinCompPressure(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MaxCompPressure(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxCompPressure(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MinConstSpeed(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinConstSpeed(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MaxConstSpeed(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxConstSpeed(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MinConstFlow(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinConstFlow(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MaxConstFlow(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxConstFlow(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MinConstTemp(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinConstTemp(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_MaxConstTemp(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxConstTemp(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_PumpStatus(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePumpStatus(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_PumpConfigurationAndControl_PumpStatus(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                uint16_t minInterval,
                                                                                                uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributePumpStatus(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_EffectiveOperationMode(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEffectiveOperationMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_EffectiveControlMode(chip::DeviceProxy * device,
                                                                                                     chip::EndpointId ZCLendpointId,
                                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEffectiveControlMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_Capacity(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCapacity(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_PumpConfigurationAndControl_Capacity(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              uint16_t minInterval,
                                                                                              uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCapacity(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_Speed(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSpeed(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_LifetimeEnergyConsumed(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLifetimeEnergyConsumed(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_OperationMode(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOperationMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_ControlMode(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeControlMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_AlarmMask(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeAlarmMask(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_FeatureMap(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeFeatureMap(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_ClusterRevision(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::PumpConfigurationAndControlCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster PumpConfigurationAndControl
// Cluster RelativeHumidityMeasurement

chip::ChipError::StorageType chip_ime_ReadAttribute_RelativeHumidityMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::RelativeHumidityMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_RelativeHumidityMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                                   chip::EndpointId ZCLendpointId,
                                                                                                   uint16_t minInterval,
                                                                                                   uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::RelativeHumidityMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                         maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_RelativeHumidityMeasurement_MinMeasuredValue(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::RelativeHumidityMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_RelativeHumidityMeasurement_MaxMeasuredValue(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::RelativeHumidityMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_RelativeHumidityMeasurement_Tolerance(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::RelativeHumidityMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTolerance(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_RelativeHumidityMeasurement_Tolerance(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               uint16_t minInterval,
                                                                                               uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::RelativeHumidityMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeTolerance(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_RelativeHumidityMeasurement_ClusterRevision(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::RelativeHumidityMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster RelativeHumidityMeasurement
// Cluster Scenes

chip::ChipError::StorageType chip_ime_ReadAttribute_Scenes_SceneCount(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ScenesCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSceneCount(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Scenes_CurrentScene(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ScenesCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentScene(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Scenes_CurrentGroup(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ScenesCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentGroup(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Scenes_SceneValid(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ScenesCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSceneValid(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Scenes_NameSupport(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ScenesCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNameSupport(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Scenes_ClusterRevision(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ScenesCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster Scenes
// Cluster SoftwareDiagnostics

chip::ChipError::StorageType chip_ime_ReadAttribute_SoftwareDiagnostics_ThreadMetrics(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SoftwareDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeThreadMetrics(gSoftwareDiagnosticsThreadMetricsListAttributeCallback.Cancel(),
                                    gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapFree(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SoftwareDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentHeapFree(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapUsed(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SoftwareDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentHeapUsed(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapHighWatermark(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SoftwareDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentHeapHighWatermark(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_SoftwareDiagnostics_ClusterRevision(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SoftwareDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster SoftwareDiagnostics
// Cluster Switch

chip::ChipError::StorageType chip_ime_ReadAttribute_Switch_NumberOfPositions(chip::DeviceProxy * device,
                                                                             chip::EndpointId ZCLendpointId,
                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SwitchCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNumberOfPositions(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Switch_CurrentPosition(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SwitchCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentPosition(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_Switch_CurrentPosition(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SwitchCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentPosition(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                           maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Switch_MultiPressMax(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SwitchCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMultiPressMax(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Switch_FeatureMap(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SwitchCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeFeatureMap(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Switch_ClusterRevision(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::SwitchCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster Switch
// Cluster TvChannel

chip::ChipError::StorageType chip_ime_ReadAttribute_TvChannel_TvChannelList(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TvChannelCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeTvChannelList(gTvChannelTvChannelListListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TvChannel_TvChannelLineup(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TvChannelCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTvChannelLineup(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TvChannel_CurrentTvChannel(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TvChannelCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentTvChannel(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TvChannel_ClusterRevision(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TvChannelCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster TvChannel
// Cluster TargetNavigator

chip::ChipError::StorageType chip_ime_ReadAttribute_TargetNavigator_TargetNavigatorList(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TargetNavigatorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeTargetNavigatorList(gTargetNavigatorTargetNavigatorListListAttributeCallback.Cancel(),
                                          gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TargetNavigator_ClusterRevision(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TargetNavigatorCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster TargetNavigator
// Cluster TemperatureMeasurement

chip::ChipError::StorageType chip_ime_ReadAttribute_TemperatureMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TemperatureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_TemperatureMeasurement_MeasuredValue(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              uint16_t minInterval,
                                                                                              uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TemperatureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                         maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TemperatureMeasurement_MinMeasuredValue(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TemperatureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TemperatureMeasurement_MaxMeasuredValue(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TemperatureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TemperatureMeasurement_Tolerance(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TemperatureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTolerance(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_TemperatureMeasurement_Tolerance(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          uint16_t minInterval,
                                                                                          uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TemperatureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeTolerance(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TemperatureMeasurement_ClusterRevision(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TemperatureMeasurementCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster TemperatureMeasurement
// Cluster TestCluster

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Boolean(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBoolean(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Bitmap8(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBitmap8(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Bitmap16(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBitmap16(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Bitmap32(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBitmap32(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Bitmap64(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBitmap64(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Int8u(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInt8u(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Int16u(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInt16u(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Int32u(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInt32u(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Int64u(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInt64u(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Int8s(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInt8s(gInt8sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Int16s(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInt16s(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Int32s(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInt32s(gInt32sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Int64s(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInt64s(gInt64sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Enum8(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEnum8(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Enum16(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEnum16(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_OctetString(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOctetString(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_ListInt8u(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeListInt8u(gTestClusterListInt8uListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_ListOctetString(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeListOctetString(gTestClusterListOctetStringListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_ListStructOctetString(chip::DeviceProxy * device,
                                                                                      chip::EndpointId ZCLendpointId,
                                                                                      chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeListStructOctetString(gTestClusterListStructOctetStringListAttributeCallback.Cancel(),
                                            gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_LongOctetString(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLongOctetString(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_CharString(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCharString(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_LongCharString(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLongCharString(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_EpochUs(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEpochUs(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_EpochS(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEpochS(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_VendorId(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeVendorId(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_ListNullablesAndOptionalsStruct(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeListNullablesAndOptionalsStruct(gTestClusterListNullablesAndOptionalsStructListAttributeCallback.Cancel(),
                                                      gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_Unsupported(chip::DeviceProxy * device,
                                                                            chip::EndpointId ZCLendpointId,
                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeUnsupported(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableBoolean(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableBoolean(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableBitmap8(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableBitmap8(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableBitmap16(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableBitmap16(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableBitmap32(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableBitmap32(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableBitmap64(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableBitmap64(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableInt8u(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableInt8u(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableInt16u(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableInt16u(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableInt32u(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableInt32u(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableInt64u(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableInt64u(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableInt8s(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableInt8s(gInt8sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableInt16s(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableInt16s(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableInt32s(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableInt32s(gInt32sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableInt64s(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableInt64s(gInt64sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableEnum8(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableEnum8(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableEnum16(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableEnum16(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableOctetString(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableOctetString(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_NullableCharString(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNullableCharString(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_TestCluster_ClusterRevision(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::TestClusterCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster TestCluster
// Cluster Thermostat

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_LocalTemperature(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLocalTemperature(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_Thermostat_LocalTemperature(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeLocalTemperature(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                            maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_AbsMinHeatSetpointLimit(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeAbsMinHeatSetpointLimit(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_AbsMaxHeatSetpointLimit(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeAbsMaxHeatSetpointLimit(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_AbsMinCoolSetpointLimit(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeAbsMinCoolSetpointLimit(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_AbsMaxCoolSetpointLimit(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeAbsMaxCoolSetpointLimit(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_OccupiedCoolingSetpoint(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOccupiedCoolingSetpoint(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_OccupiedHeatingSetpoint(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOccupiedHeatingSetpoint(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_MinHeatSetpointLimit(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinHeatSetpointLimit(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_MaxHeatSetpointLimit(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxHeatSetpointLimit(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_MinCoolSetpointLimit(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinCoolSetpointLimit(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_MaxCoolSetpointLimit(chip::DeviceProxy * device,
                                                                                    chip::EndpointId ZCLendpointId,
                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMaxCoolSetpointLimit(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_MinSetpointDeadBand(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMinSetpointDeadBand(gInt8sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_ControlSequenceOfOperation(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeControlSequenceOfOperation(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_SystemMode(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSystemMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_StartOfWeek(chip::DeviceProxy * device,
                                                                           chip::EndpointId ZCLendpointId,
                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStartOfWeek(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_NumberOfWeeklyTransitions(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNumberOfWeeklyTransitions(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_NumberOfDailyTransitions(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNumberOfDailyTransitions(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_FeatureMap(chip::DeviceProxy * device,
                                                                          chip::EndpointId ZCLendpointId,
                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeFeatureMap(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_ClusterRevision(chip::DeviceProxy * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster Thermostat
// Cluster ThermostatUserInterfaceConfiguration

chip::ChipError::StorageType chip_ime_ReadAttribute_ThermostatUserInterfaceConfiguration_TemperatureDisplayMode(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatUserInterfaceConfigurationCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTemperatureDisplayMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThermostatUserInterfaceConfiguration_KeypadLockout(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatUserInterfaceConfigurationCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeKeypadLockout(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThermostatUserInterfaceConfiguration_ScheduleProgrammingVisibility(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatUserInterfaceConfigurationCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeScheduleProgrammingVisibility(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThermostatUserInterfaceConfiguration_ClusterRevision(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThermostatUserInterfaceConfigurationCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster ThermostatUserInterfaceConfiguration
// Cluster ThreadNetworkDiagnostics

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_Channel(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeChannel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RoutingRole(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRoutingRole(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_NetworkName(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeNetworkName(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_PanId(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePanId(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_ExtendedPanId(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeExtendedPanId(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_MeshLocalPrefix(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMeshLocalPrefix(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_OverrunCount(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOverrunCount(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_NeighborTableList(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeNeighborTableList(gThreadNetworkDiagnosticsNeighborTableListListAttributeCallback.Cancel(),
                                        gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RouteTableList(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeRouteTableList(gThreadNetworkDiagnosticsRouteTableListListAttributeCallback.Cancel(),
                                     gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_PartitionId(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePartitionId(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_Weighting(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeWeighting(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_DataVersion(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDataVersion(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_StableDataVersion(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeStableDataVersion(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_LeaderRouterId(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLeaderRouterId(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_DetachedRoleCount(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDetachedRoleCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_ChildRoleCount(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeChildRoleCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RouterRoleCount(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRouterRoleCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_LeaderRoleCount(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeLeaderRoleCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_AttachAttemptCount(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeAttachAttemptCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_PartitionIdChangeCount(chip::DeviceProxy * device,
                                                                                                    chip::EndpointId ZCLendpointId,
                                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePartitionIdChangeCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_BetterPartitionAttachAttemptCount(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeBetterPartitionAttachAttemptCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_ParentChangeCount(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeParentChangeCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxTotalCount(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxTotalCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxUnicastCount(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxUnicastCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxBroadcastCount(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxBroadcastCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxAckRequestedCount(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxAckRequestedCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxAckedCount(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxAckedCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxNoAckRequestedCount(chip::DeviceProxy * device,
                                                                                                   chip::EndpointId ZCLendpointId,
                                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxNoAckRequestedCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxDataCount(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxDataCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxDataPollCount(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxDataPollCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxBeaconCount(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxBeaconCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxBeaconRequestCount(chip::DeviceProxy * device,
                                                                                                  chip::EndpointId ZCLendpointId,
                                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxBeaconRequestCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxOtherCount(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxOtherCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxRetryCount(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxRetryCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxDirectMaxRetryExpiryCount(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxDirectMaxRetryExpiryCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxIndirectMaxRetryExpiryCount(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxIndirectMaxRetryExpiryCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxErrCcaCount(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxErrCcaCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxErrAbortCount(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxErrAbortCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_TxErrBusyChannelCount(chip::DeviceProxy * device,
                                                                                                   chip::EndpointId ZCLendpointId,
                                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTxErrBusyChannelCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxTotalCount(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxTotalCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxUnicastCount(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxUnicastCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxBroadcastCount(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxBroadcastCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxDataCount(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxDataCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxDataPollCount(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxDataPollCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxBeaconCount(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxBeaconCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxBeaconRequestCount(chip::DeviceProxy * device,
                                                                                                  chip::EndpointId ZCLendpointId,
                                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxBeaconRequestCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxOtherCount(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxOtherCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxAddressFilteredCount(chip::DeviceProxy * device,
                                                                                                    chip::EndpointId ZCLendpointId,
                                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxAddressFilteredCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxDestAddrFilteredCount(chip::DeviceProxy * device,
                                                                                                     chip::EndpointId ZCLendpointId,
                                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxDestAddrFilteredCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxDuplicatedCount(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxDuplicatedCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxErrNoFrameCount(chip::DeviceProxy * device,
                                                                                               chip::EndpointId ZCLendpointId,
                                                                                               chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxErrNoFrameCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxErrUnknownNeighborCount(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxErrUnknownNeighborCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType
chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxErrInvalidSrcAddrCount(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxErrInvalidSrcAddrCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxErrSecCount(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxErrSecCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxErrFcsCount(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxErrFcsCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_RxErrOtherCount(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRxErrOtherCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_ActiveTimestamp(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeActiveTimestamp(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_PendingTimestamp(chip::DeviceProxy * device,
                                                                                              chip::EndpointId ZCLendpointId,
                                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePendingTimestamp(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_Delay(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeDelay(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_SecurityPolicy(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeSecurityPolicy(gThreadNetworkDiagnosticsSecurityPolicyListAttributeCallback.Cancel(),
                                     gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_ChannelMask(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeChannelMask(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_OperationalDatasetComponents(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeOperationalDatasetComponents(
            gThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_ActiveNetworkFaultsList(chip::DeviceProxy * device,
                                                                                                     chip::EndpointId ZCLendpointId,
                                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeActiveNetworkFaultsList(gThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback.Cancel(),
                                              gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_ThreadNetworkDiagnostics_ClusterRevision(chip::DeviceProxy * device,
                                                                                             chip::EndpointId ZCLendpointId,
                                                                                             chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::ThreadNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster ThreadNetworkDiagnostics
// Cluster WakeOnLan

chip::ChipError::StorageType chip_ime_ReadAttribute_WakeOnLan_WakeOnLanMacAddress(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WakeOnLanCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeWakeOnLanMacAddress(gCharStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WakeOnLan_ClusterRevision(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WakeOnLanCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster WakeOnLan
// Cluster WiFiNetworkDiagnostics

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_Bssid(chip::DeviceProxy * device,
                                                                                 chip::EndpointId ZCLendpointId,
                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBssid(gOctetStringAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_SecurityType(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSecurityType(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_WiFiVersion(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeWiFiVersion(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_ChannelNumber(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeChannelNumber(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_Rssi(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeRssi(gInt8sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_BeaconLostCount(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBeaconLostCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_BeaconRxCount(chip::DeviceProxy * device,
                                                                                         chip::EndpointId ZCLendpointId,
                                                                                         chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeBeaconRxCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_PacketMulticastRxCount(chip::DeviceProxy * device,
                                                                                                  chip::EndpointId ZCLendpointId,
                                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePacketMulticastRxCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_PacketMulticastTxCount(chip::DeviceProxy * device,
                                                                                                  chip::EndpointId ZCLendpointId,
                                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePacketMulticastTxCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_PacketUnicastRxCount(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePacketUnicastRxCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_PacketUnicastTxCount(chip::DeviceProxy * device,
                                                                                                chip::EndpointId ZCLendpointId,
                                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributePacketUnicastTxCount(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_CurrentMaxRate(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentMaxRate(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_OverrunCount(chip::DeviceProxy * device,
                                                                                        chip::EndpointId ZCLendpointId,
                                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOverrunCount(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WiFiNetworkDiagnostics_ClusterRevision(chip::DeviceProxy * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WiFiNetworkDiagnosticsCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster WiFiNetworkDiagnostics
// Cluster WindowCovering

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_Type(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeType(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositionLift(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentPositionLift(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositionTilt(chip::DeviceProxy * device,
                                                                                       chip::EndpointId ZCLendpointId,
                                                                                       chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentPositionTilt(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_ConfigStatus(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeConfigStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositionLiftPercentage(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentPositionLiftPercentage(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType
chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercentage(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentPositionLiftPercentage(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(),
                                                         minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositionTiltPercentage(chip::DeviceProxy * device,
                                                                                                 chip::EndpointId ZCLendpointId,
                                                                                                 chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeCurrentPositionTiltPercentage(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType
chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercentage(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                         uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentPositionTiltPercentage(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(),
                                                         minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_OperationalStatus(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeOperationalStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_OperationalStatus(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          uint16_t minInterval,
                                                                                          uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeOperationalStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                             maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_TargetPositionLiftPercent100ths(chip::DeviceProxy * device,
                                                                                                   chip::EndpointId ZCLendpointId,
                                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTargetPositionLiftPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_TargetPositionLiftPercent100ths(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeTargetPositionLiftPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(),
                                                           minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_TargetPositionTiltPercent100ths(chip::DeviceProxy * device,
                                                                                                   chip::EndpointId ZCLendpointId,
                                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeTargetPositionTiltPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_TargetPositionTiltPercent100ths(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeTargetPositionTiltPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(),
                                                           minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_EndProductType(chip::DeviceProxy * device,
                                                                                  chip::EndpointId ZCLendpointId,
                                                                                  chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeEndProductType(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositionLiftPercent100ths(chip::DeviceProxy * device,
                                                                                                    chip::EndpointId ZCLendpointId,
                                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeCurrentPositionLiftPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercent100ths(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentPositionLiftPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(),
                                                            minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositionTiltPercent100ths(chip::DeviceProxy * device,
                                                                                                    chip::EndpointId ZCLendpointId,
                                                                                                    chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .ReadAttributeCurrentPositionTiltPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercent100ths(
    chip::DeviceProxy * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeCurrentPositionTiltPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(),
                                                            minInterval, maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_InstalledOpenLimitLift(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInstalledOpenLimitLift(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_InstalledClosedLimitLift(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInstalledClosedLimitLift(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_InstalledOpenLimitTilt(chip::DeviceProxy * device,
                                                                                          chip::EndpointId ZCLendpointId,
                                                                                          chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInstalledOpenLimitTilt(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_InstalledClosedLimitTilt(chip::DeviceProxy * device,
                                                                                            chip::EndpointId ZCLendpointId,
                                                                                            chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeInstalledClosedLimitTilt(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_Mode(chip::DeviceProxy * device, chip::EndpointId ZCLendpointId,
                                                                        chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeMode(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_SafetyStatus(chip::DeviceProxy * device,
                                                                                chip::EndpointId ZCLendpointId,
                                                                                chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeSafetyStatus(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_SafetyStatus(chip::DeviceProxy * device,
                                                                                     chip::EndpointId ZCLendpointId,
                                                                                     uint16_t minInterval, uint16_t maxInterval)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster
        .SubscribeAttributeSafetyStatus(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval,
                                        maxInterval)
        .AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_FeatureMap(chip::DeviceProxy * device,
                                                                              chip::EndpointId ZCLendpointId,
                                                                              chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeFeatureMap(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_ClusterRevision(chip::DeviceProxy * device,
                                                                                   chip::EndpointId ZCLendpointId,
                                                                                   chip::GroupId /* ZCLgroupId */)
{
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
    chip::Controller::WindowCoveringCluster cluster;
    cluster.Associate(device, ZCLendpointId);
    return cluster.ReadAttributeClusterRevision(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}

// End of Cluster WindowCovering
}