/*

 *

 *    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/UnitTesting/AttributeIds.h>

#include <clusters/UnitTesting/ClusterId.h>

#include <clusters/UnitTesting/Enums.h>

#include <clusters/UnitTesting/Structs.h>

namespace chip {

namespace app {

namespace Clusters {

namespace UnitTesting {

namespace Attributes {

namespace Boolean {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Boolean

namespace Bitmap8 {

struct TypeInfo

{

    using Type             = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;

    using DecodableType    = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;

    using DecodableArgType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Bitmap8

namespace Bitmap16 {

struct TypeInfo

{

    using Type             = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;

    using DecodableType    = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;

    using DecodableArgType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Bitmap16

namespace Bitmap32 {

struct TypeInfo

{

    using Type             = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;

    using DecodableType    = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;

    using DecodableArgType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Bitmap32

namespace Bitmap64 {

struct TypeInfo

{

    using Type             = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;

    using DecodableType    = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;

    using DecodableArgType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Bitmap64

namespace Int8u {

struct TypeInfo

{

    using Type             = uint8_t;

    using DecodableType    = uint8_t;

    using DecodableArgType = uint8_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int8u

namespace Int16u {

struct TypeInfo

{

    using Type             = uint16_t;

    using DecodableType    = uint16_t;

    using DecodableArgType = uint16_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int16u

namespace Int24u {

struct TypeInfo

{

    using Type             = uint32_t;

    using DecodableType    = uint32_t;

    using DecodableArgType = uint32_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int24u

namespace Int32u {

struct TypeInfo

{

    using Type             = uint32_t;

    using DecodableType    = uint32_t;

    using DecodableArgType = uint32_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int32u

namespace Int40u {

struct TypeInfo

{

    using Type             = uint64_t;

    using DecodableType    = uint64_t;

    using DecodableArgType = uint64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int40u

namespace Int48u {

struct TypeInfo

{

    using Type             = uint64_t;

    using DecodableType    = uint64_t;

    using DecodableArgType = uint64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int48u

namespace Int56u {

struct TypeInfo

{

    using Type             = uint64_t;

    using DecodableType    = uint64_t;

    using DecodableArgType = uint64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int56u

namespace Int64u {

struct TypeInfo

{

    using Type             = uint64_t;

    using DecodableType    = uint64_t;

    using DecodableArgType = uint64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int64u

namespace Int8s {

struct TypeInfo

{

    using Type             = int8_t;

    using DecodableType    = int8_t;

    using DecodableArgType = int8_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int8s

namespace Int16s {

struct TypeInfo

{

    using Type             = int16_t;

    using DecodableType    = int16_t;

    using DecodableArgType = int16_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int16s

namespace Int24s {

struct TypeInfo

{

    using Type             = int32_t;

    using DecodableType    = int32_t;

    using DecodableArgType = int32_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int24s

namespace Int32s {

struct TypeInfo

{

    using Type             = int32_t;

    using DecodableType    = int32_t;

    using DecodableArgType = int32_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int32s

namespace Int40s {

struct TypeInfo

{

    using Type             = int64_t;

    using DecodableType    = int64_t;

    using DecodableArgType = int64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int40s

namespace Int48s {

struct TypeInfo

{

    using Type             = int64_t;

    using DecodableType    = int64_t;

    using DecodableArgType = int64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int48s

namespace Int56s {

struct TypeInfo

{

    using Type             = int64_t;

    using DecodableType    = int64_t;

    using DecodableArgType = int64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int56s

namespace Int64s {

struct TypeInfo

{

    using Type             = int64_t;

    using DecodableType    = int64_t;

    using DecodableArgType = int64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Int64s

namespace Enum8 {

struct TypeInfo

{

    using Type             = uint8_t;

    using DecodableType    = uint8_t;

    using DecodableArgType = uint8_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Enum8

namespace Enum16 {

struct TypeInfo

{

    using Type             = uint16_t;

    using DecodableType    = uint16_t;

    using DecodableArgType = uint16_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Enum16

namespace FloatSingle {

struct TypeInfo

{

    using Type             = float;

    using DecodableType    = float;

    using DecodableArgType = float;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace FloatSingle

namespace FloatDouble {

struct TypeInfo

{

    using Type             = double;

    using DecodableType    = double;

    using DecodableArgType = double;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace FloatDouble

namespace OctetString {

struct TypeInfo

{

    using Type             = chip::ByteSpan;

    using DecodableType    = chip::ByteSpan;

    using DecodableArgType = chip::ByteSpan;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 10; }

};

} // namespace OctetString

namespace ListInt8u {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ListInt8u

namespace ListOctetString {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ListOctetString

namespace ListStructOctetString {

struct TypeInfo

{

    using Type = chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::Type>;

    using DecodableType =

        chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::DecodableType>;

    using DecodableArgType =

        const chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::DecodableType> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ListStructOctetString

namespace LongOctetString {

struct TypeInfo

{

    using Type             = chip::ByteSpan;

    using DecodableType    = chip::ByteSpan;

    using DecodableArgType = chip::ByteSpan;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 1000; }

};

} // namespace LongOctetString

namespace CharString {

struct TypeInfo

{

    using Type             = chip::CharSpan;

    using DecodableType    = chip::CharSpan;

    using DecodableArgType = chip::CharSpan;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 10; }

};

} // namespace CharString

namespace LongCharString {

struct TypeInfo

{

    using Type             = chip::CharSpan;

    using DecodableType    = chip::CharSpan;

    using DecodableArgType = chip::CharSpan;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 1000; }

};

} // namespace LongCharString

namespace EpochUs {

struct TypeInfo

{

    using Type             = uint64_t;

    using DecodableType    = uint64_t;

    using DecodableArgType = uint64_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace EpochUs

namespace EpochS {

struct TypeInfo

{

    using Type             = uint32_t;

    using DecodableType    = uint32_t;

    using DecodableArgType = uint32_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace EpochS

namespace VendorId {

struct TypeInfo

{

    using Type             = chip::VendorId;

    using DecodableType    = chip::VendorId;

    using DecodableArgType = chip::VendorId;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace VendorId

namespace ListNullablesAndOptionalsStruct {

struct TypeInfo

{

    using Type = chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::Type>;

    using DecodableType =

        chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType>;

    using DecodableArgType = const chip::app::DataModel::DecodableList<

        chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ListNullablesAndOptionalsStruct

namespace EnumAttr {

struct TypeInfo

{

    using Type             = chip::app::Clusters::UnitTesting::SimpleEnum;

    using DecodableType    = chip::app::Clusters::UnitTesting::SimpleEnum;

    using DecodableArgType = chip::app::Clusters::UnitTesting::SimpleEnum;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace EnumAttr

namespace StructAttr {

struct TypeInfo

{

    using Type             = chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type;

    using DecodableType    = chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType;

    using DecodableArgType = const chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace StructAttr

namespace RangeRestrictedInt8u {

struct TypeInfo

{

    using Type             = uint8_t;

    using DecodableType    = uint8_t;

    using DecodableArgType = uint8_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace RangeRestrictedInt8u

namespace RangeRestrictedInt8s {

struct TypeInfo

{

    using Type             = int8_t;

    using DecodableType    = int8_t;

    using DecodableArgType = int8_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace RangeRestrictedInt8s

namespace RangeRestrictedInt16u {

struct TypeInfo

{

    using Type             = uint16_t;

    using DecodableType    = uint16_t;

    using DecodableArgType = uint16_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace RangeRestrictedInt16u

namespace RangeRestrictedInt16s {

struct TypeInfo

{

    using Type             = int16_t;

    using DecodableType    = int16_t;

    using DecodableArgType = int16_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace RangeRestrictedInt16s

namespace ListLongOctetString {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ListLongOctetString

namespace ListFabricScoped {

struct TypeInfo

{

    using Type = chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::Type>;

    using DecodableType =

        chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::DecodableType>;

    using DecodableArgType =

        const chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::DecodableType> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ListFabricScoped

namespace TimedWriteBoolean {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

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

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

    static constexpr bool MustUseTimedWrite() { return true; }

};

} // namespace TimedWriteBoolean

namespace GeneralErrorBoolean {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace GeneralErrorBoolean

namespace ClusterErrorBoolean {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ClusterErrorBoolean

namespace GlobalEnum {

struct TypeInfo

{

    using Type             = chip::app::Clusters::Globals::TestGlobalEnum;

    using DecodableType    = chip::app::Clusters::Globals::TestGlobalEnum;

    using DecodableArgType = chip::app::Clusters::Globals::TestGlobalEnum;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace GlobalEnum

namespace GlobalStruct {

struct TypeInfo

{

    using Type             = chip::app::Clusters::Globals::Structs::TestGlobalStruct::Type;

    using DecodableType    = chip::app::Clusters::Globals::Structs::TestGlobalStruct::DecodableType;

    using DecodableArgType = const chip::app::Clusters::Globals::Structs::TestGlobalStruct::DecodableType &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace GlobalStruct

namespace UnsupportedAttributeRequiringAdminPrivilege {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace UnsupportedAttributeRequiringAdminPrivilege

namespace Unsupported {

struct TypeInfo

{

    using Type             = bool;

    using DecodableType    = bool;

    using DecodableArgType = bool;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace Unsupported

namespace ReadFailureCode {

struct TypeInfo

{

    using Type             = uint8_t;

    using DecodableType    = uint8_t;

    using DecodableArgType = uint8_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace ReadFailureCode

namespace FailureInt32U {

struct TypeInfo

{

    using Type             = uint32_t;

    using DecodableType    = uint32_t;

    using DecodableArgType = uint32_t;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace FailureInt32U

namespace NullableBoolean {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableBoolean

namespace NullableBitmap8 {

struct TypeInfo

{

    using Type          = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;

    using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;

    using DecodableArgType =

        const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableBitmap8

namespace NullableBitmap16 {

struct TypeInfo

{

    using Type          = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;

    using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;

    using DecodableArgType =

        const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableBitmap16

namespace NullableBitmap32 {

struct TypeInfo

{

    using Type          = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;

    using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;

    using DecodableArgType =

        const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableBitmap32

namespace NullableBitmap64 {

struct TypeInfo

{

    using Type          = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;

    using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;

    using DecodableArgType =

        const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableBitmap64

namespace NullableInt8u {

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::UnitTesting::Id; }

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt8u

namespace NullableInt16u {

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::UnitTesting::Id; }

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt16u

namespace NullableInt24u {

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::UnitTesting::Id; }

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt24u

namespace NullableInt32u {

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::UnitTesting::Id; }

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt32u

namespace NullableInt40u {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt40u

namespace NullableInt48u {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt48u

namespace NullableInt56u {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt56u

namespace NullableInt64u {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt64u

namespace NullableInt8s {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt8s

namespace NullableInt16s {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt16s

namespace NullableInt24s {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt24s

namespace NullableInt32s {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt32s

namespace NullableInt40s {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt40s

namespace NullableInt48s {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt48s

namespace NullableInt56s {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt56s

namespace NullableInt64s {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableInt64s

namespace NullableEnum8 {

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::UnitTesting::Id; }

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableEnum8

namespace NullableEnum16 {

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::UnitTesting::Id; }

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableEnum16

namespace NullableFloatSingle {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableFloatSingle

namespace NullableFloatDouble {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableFloatDouble

namespace NullableOctetString {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 10; }

};

} // namespace NullableOctetString

namespace NullableCharString {

struct TypeInfo

{

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

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

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

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

    static constexpr size_t MaxLength() { return 10; }

};

} // namespace NullableCharString

namespace NullableEnumAttr {

struct TypeInfo

{

    using Type             = chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum>;

    using DecodableType    = chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum>;

    using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableEnumAttr

namespace NullableStruct {

struct TypeInfo

{

    using Type          = chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>;

    using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType>;

    using DecodableArgType =

        const chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType> &;

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

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableStruct

namespace NullableRangeRestrictedInt8u {

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::UnitTesting::Id; }

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

    static constexpr bool MustUseTimedWrite() { return false; }

};

} // namespace NullableRangeRestrictedInt8u

namespace NullableRangeRestrictedInt8s {

struct TypeInfo

{

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

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

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

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