/*

 *

 *    Copyright (c) 2022 Project CHIP Authors

 *

 *    Licensed under the Apache License, Version 2.0 (the "License");

 *    you may not use this file except in compliance with the License.

 *    You may obtain a copy of the License at

 *

 *        http://www.apache.org/licenses/LICENSE-2.0

 *

 *    Unless required by applicable law or agreed to in writing, software

 *    distributed under the License is distributed on an "AS IS" BASIS,

 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *    See the License for the specific language governing permissions and

 *    limitations under the License.

 */

// THIS FILE IS GENERATED BY ZAP

// This file is generated from clusters-Attributes.h.zapt

#pragma once

#include <app/ConcreteAttributePath.h>

#include <app/data-model/DecodableList.h>

#include <app/data-model/List.h>

#include <app/data-model/Nullable.h>

#include <app/util/basic-types.h>

#include <lib/core/TLV.h>

#include <lib/support/BitMask.h>

#include <clusters/shared/Attributes.h>

#include <clusters/shared/Enums.h>

#include <clusters/shared/Structs.h>

#include <clusters/PowerSource/AttributeIds.h>

#include <clusters/PowerSource/ClusterId.h>

#include <clusters/PowerSource/Enums.h>

#include <clusters/PowerSource/Structs.h>

namespace chip {

namespace app {

namespace Clusters {

namespace PowerSource {

namespace Attributes {

namespace Status {

struct TypeInfo

{

    using Type             = chip::app::Clusters::PowerSource::PowerSourceStatusEnum;

    using DecodableType    = chip::app::Clusters::PowerSource::PowerSourceStatusEnum;

    using DecodableArgType = chip::app::Clusters::PowerSource::PowerSourceStatusEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::Status::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Status

namespace Order {

struct TypeInfo

{

    using Type             = uint8_t;

    using DecodableType    = uint8_t;

    using DecodableArgType = uint8_t;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::Order::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Order

namespace Description {

struct TypeInfo

{

    using Type             = chip::CharSpan;

    using DecodableType    = chip::CharSpan;

    using DecodableArgType = chip::CharSpan;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::Description::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 60; }

};

} // namespace Description

namespace WiredAssessedInputVoltage {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableType    = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedInputVoltage::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace WiredAssessedInputVoltage

namespace WiredAssessedInputFrequency {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<uint16_t>;

    using DecodableType    = chip::app::DataModel::Nullable<uint16_t>;

    using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedInputFrequency::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace WiredAssessedInputFrequency

namespace WiredCurrentType {

struct TypeInfo

{

    using Type             = chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;

    using DecodableType    = chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;

    using DecodableArgType = chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::WiredCurrentType::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace WiredCurrentType

namespace WiredAssessedCurrent {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableType    = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedCurrent::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace WiredAssessedCurrent

namespace WiredNominalVoltage {

struct TypeInfo

{

    using Type             = uint32_t;

    using DecodableType    = uint32_t;

    using DecodableArgType = uint32_t;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::WiredNominalVoltage::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace WiredNominalVoltage

namespace WiredMaximumCurrent {

struct TypeInfo

{

    using Type             = uint32_t;

    using DecodableType    = uint32_t;

    using DecodableArgType = uint32_t;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::WiredMaximumCurrent::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace WiredMaximumCurrent

namespace WiredPresent {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::WiredPresent::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace WiredPresent

namespace ActiveWiredFaults {

struct TypeInfo

{

    using Type             = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::WiredFaultEnum>;

    using DecodableType    = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFaultEnum>;

    using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFaultEnum> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveWiredFaults::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ActiveWiredFaults

namespace BatVoltage {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableType    = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatVoltage::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatVoltage

namespace BatPercentRemaining {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<uint8_t>;

    using DecodableType    = chip::app::DataModel::Nullable<uint8_t>;

    using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatPercentRemaining::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatPercentRemaining

namespace BatTimeRemaining {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableType    = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatTimeRemaining::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatTimeRemaining

namespace BatChargeLevel {

struct TypeInfo

{

    using Type             = chip::app::Clusters::PowerSource::BatChargeLevelEnum;

    using DecodableType    = chip::app::Clusters::PowerSource::BatChargeLevelEnum;

    using DecodableArgType = chip::app::Clusters::PowerSource::BatChargeLevelEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatChargeLevel::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatChargeLevel

namespace BatReplacementNeeded {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatReplacementNeeded::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatReplacementNeeded

namespace BatReplaceability {

struct TypeInfo

{

    using Type             = chip::app::Clusters::PowerSource::BatReplaceabilityEnum;

    using DecodableType    = chip::app::Clusters::PowerSource::BatReplaceabilityEnum;

    using DecodableArgType = chip::app::Clusters::PowerSource::BatReplaceabilityEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatReplaceability::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatReplaceability

namespace BatPresent {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatPresent::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatPresent

namespace ActiveBatFaults {

struct TypeInfo

{

    using Type             = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::BatFaultEnum>;

    using DecodableType    = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFaultEnum>;

    using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFaultEnum> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatFaults::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ActiveBatFaults

namespace BatReplacementDescription {

struct TypeInfo

{

    using Type             = chip::CharSpan;

    using DecodableType    = chip::CharSpan;

    using DecodableArgType = chip::CharSpan;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatReplacementDescription::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 60; }

};

} // namespace BatReplacementDescription

namespace BatCommonDesignation {

struct TypeInfo

{

    using Type             = chip::app::Clusters::PowerSource::BatCommonDesignationEnum;

    using DecodableType    = chip::app::Clusters::PowerSource::BatCommonDesignationEnum;

    using DecodableArgType = chip::app::Clusters::PowerSource::BatCommonDesignationEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatCommonDesignation::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatCommonDesignation

namespace BatANSIDesignation {

struct TypeInfo

{

    using Type             = chip::CharSpan;

    using DecodableType    = chip::CharSpan;

    using DecodableArgType = chip::CharSpan;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatANSIDesignation::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 20; }

};

} // namespace BatANSIDesignation

namespace BatIECDesignation {

struct TypeInfo

{

    using Type             = chip::CharSpan;

    using DecodableType    = chip::CharSpan;

    using DecodableArgType = chip::CharSpan;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatIECDesignation::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 20; }

};

} // namespace BatIECDesignation

namespace BatApprovedChemistry {

struct TypeInfo

{

    using Type             = chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;

    using DecodableType    = chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;

    using DecodableArgType = chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatApprovedChemistry::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatApprovedChemistry

namespace BatCapacity {

struct TypeInfo

{

    using Type             = uint32_t;

    using DecodableType    = uint32_t;

    using DecodableArgType = uint32_t;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatCapacity::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatCapacity

namespace BatQuantity {

struct TypeInfo

{

    using Type             = uint8_t;

    using DecodableType    = uint8_t;

    using DecodableArgType = uint8_t;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatQuantity::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatQuantity

namespace BatChargeState {

struct TypeInfo

{

    using Type             = chip::app::Clusters::PowerSource::BatChargeStateEnum;

    using DecodableType    = chip::app::Clusters::PowerSource::BatChargeStateEnum;

    using DecodableArgType = chip::app::Clusters::PowerSource::BatChargeStateEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatChargeState::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatChargeState

namespace BatTimeToFullCharge {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableType    = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatTimeToFullCharge::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatTimeToFullCharge

namespace BatFunctionalWhileCharging {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatFunctionalWhileCharging::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatFunctionalWhileCharging

namespace BatChargingCurrent {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableType    = chip::app::DataModel::Nullable<uint32_t>;

    using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::BatChargingCurrent::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace BatChargingCurrent

namespace ActiveBatChargeFaults {

struct TypeInfo

{

    using Type             = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::BatChargeFaultEnum>;

    using DecodableType    = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFaultEnum>;

    using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFaultEnum> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatChargeFaults::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ActiveBatChargeFaults

namespace EndpointList {

struct TypeInfo

{

    using Type             = chip::app::DataModel::List<const chip::EndpointId>;

    using DecodableType    = chip::app::DataModel::DecodableList<chip::EndpointId>;

    using DecodableArgType = const chip::app::DataModel::DecodableList<chip::EndpointId> &;

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

    static constexpr AttributeId GetAttributeId() { return Attributes::EndpointList::Id; }

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace EndpointList

namespace GeneratedCommandList {

struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo

{

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

};

} // namespace GeneratedCommandList

namespace AcceptedCommandList {

struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo

{

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

};

} // namespace AcceptedCommandList

namespace AttributeList {

struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo

{

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

};

} // namespace AttributeList

namespace FeatureMap {

struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo

{

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

};

} // namespace FeatureMap

namespace ClusterRevision {

struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo

{

    static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

};

} // namespace ClusterRevision

struct TypeInfo

{

    struct DecodableType

    {

        static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }

        CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);

        Attributes::Status::TypeInfo::DecodableType status =

            static_cast<chip::app::Clusters::PowerSource::PowerSourceStatusEnum>(0);

        Attributes::Order::TypeInfo::DecodableType order = static_cast<uint8_t>(0);

        Attributes::Description::TypeInfo::DecodableType description;

        Attributes::WiredAssessedInputVoltage::TypeInfo::DecodableType wiredAssessedInputVoltage;

        Attributes::WiredAssessedInputFrequency::TypeInfo::DecodableType wiredAssessedInputFrequency;

        Attributes::WiredCurrentType::TypeInfo::DecodableType wiredCurrentType =

            static_cast<chip::app::Clusters::PowerSource::WiredCurrentTypeEnum>(0);

        Attributes::WiredAssessedCurrent::TypeInfo::DecodableType wiredAssessedCurrent;

        Attributes::WiredNominalVoltage::TypeInfo::DecodableType wiredNominalVoltage = static_cast<uint32_t>(0);

        Attributes::WiredMaximumCurrent::TypeInfo::DecodableType wiredMaximumCurrent = static_cast<uint32_t>(0);

        Attributes::WiredPresent::TypeInfo::DecodableType wiredPresent               = static_cast<bool>(0);

        Attributes::ActiveWiredFaults::TypeInfo::DecodableType activeWiredFaults;

        Attributes::BatVoltage::TypeInfo::DecodableType batVoltage;

        Attributes::BatPercentRemaining::TypeInfo::DecodableType batPercentRemaining;

        Attributes::BatTimeRemaining::TypeInfo::DecodableType batTimeRemaining;

        Attributes::BatChargeLevel::TypeInfo::DecodableType batChargeLevel =

            static_cast<chip::app::Clusters::PowerSource::BatChargeLevelEnum>(0);

        Attributes::BatReplacementNeeded::TypeInfo::DecodableType batReplacementNeeded = static_cast<bool>(0);

        Attributes::BatReplaceability::TypeInfo::DecodableType batReplaceability =

            static_cast<chip::app::Clusters::PowerSource::BatReplaceabilityEnum>(0);

        Attributes::BatPresent::TypeInfo::DecodableType batPresent = static_cast<bool>(0);

        Attributes::ActiveBatFaults::TypeInfo::DecodableType activeBatFaults;

        Attributes::BatReplacementDescription::TypeInfo::DecodableType batReplacementDescription;

        Attributes::BatCommonDesignation::TypeInfo::DecodableType batCommonDesignation =

            static_cast<chip::app::Clusters::PowerSource::BatCommonDesignationEnum>(0);

        Attributes::BatANSIDesignation::TypeInfo::DecodableType batANSIDesignation;

        Attributes::BatIECDesignation::TypeInfo::DecodableType batIECDesignation;

        Attributes::BatApprovedChemistry::TypeInfo::DecodableType batApprovedChemistry =

            static_cast<chip::app::Clusters::PowerSource::BatApprovedChemistryEnum>(0);

        Attributes::BatCapacity::TypeInfo::DecodableType batCapacity = static_cast<uint32_t>(0);

        Attributes::BatQuantity::TypeInfo::DecodableType batQuantity = static_cast<uint8_t>(0);

        Attributes::BatChargeState::TypeInfo::DecodableType batChargeState =

            static_cast<chip::app::Clusters::PowerSource::BatChargeStateEnum>(0);

        Attributes::BatTimeToFullCharge::TypeInfo::DecodableType batTimeToFullCharge;

        Attributes::BatFunctionalWhileCharging::TypeInfo::DecodableType batFunctionalWhileCharging = static_cast<bool>(0);

        Attributes::BatChargingCurrent::TypeInfo::DecodableType batChargingCurrent;

        Attributes::ActiveBatChargeFaults::TypeInfo::DecodableType activeBatChargeFaults;

        Attributes::EndpointList::TypeInfo::DecodableType endpointList;

        Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;

        Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;

        Attributes::AttributeList::TypeInfo::DecodableType attributeList;

        Attributes::FeatureMap::TypeInfo::DecodableType featureMap           = static_cast<uint32_t>(0);

        Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);

    };

};

} // namespace Attributes

} // namespace PowerSource

} // namespace Clusters

} // namespace app

} // namespace chip