/*
 *
 *    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 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;
  }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NullableRangeRestrictedInt8s::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NullableRangeRestrictedInt8s
namespace NullableRangeRestrictedInt16u {
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::NullableRangeRestrictedInt16u::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NullableRangeRestrictedInt16u
namespace NullableRangeRestrictedInt16s {
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::NullableRangeRestrictedInt16s::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NullableRangeRestrictedInt16s
namespace WriteOnlyInt8u {
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::WriteOnlyInt8u::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace WriteOnlyInt8u
namespace NullableGlobalEnum {
struct TypeInfo {
  using Type = chip::app::DataModel::Nullable<
      chip::app::Clusters::Globals::TestGlobalEnum>;
  using DecodableType = chip::app::DataModel::Nullable<
      chip::app::Clusters::Globals::TestGlobalEnum>;
  using DecodableArgType = const chip::app::DataModel::Nullable<
      chip::app::Clusters::Globals::TestGlobalEnum> &;

  static constexpr ClusterId GetClusterId() {
    return Clusters::UnitTesting::Id;
  }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NullableGlobalEnum::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NullableGlobalEnum
namespace NullableGlobalStruct {
struct TypeInfo {
  using Type = chip::app::DataModel::Nullable<
      chip::app::Clusters::Globals::Structs::TestGlobalStruct::Type>;
  using DecodableType = chip::app::DataModel::Nullable<
      chip::app::Clusters::Globals::Structs::TestGlobalStruct::DecodableType>;
  using DecodableArgType = const chip::app::DataModel::Nullable<
      chip::app::Clusters::Globals::Structs::TestGlobalStruct::DecodableType> &;

  static constexpr ClusterId GetClusterId() {
    return Clusters::UnitTesting::Id;
  }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NullableGlobalStruct::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NullableGlobalStruct
namespace GeneratedCommandList {
struct TypeInfo
    : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo {
  static constexpr ClusterId GetClusterId() {
    return Clusters::UnitTesting::Id;
  }
};
} // namespace GeneratedCommandList
namespace AcceptedCommandList {
struct TypeInfo
    : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo {
  static constexpr ClusterId GetClusterId() {
    return Clusters::UnitTesting::Id;
  }
};
} // namespace AcceptedCommandList
namespace AttributeList {
struct TypeInfo
    : public Clusters::Globals::Attributes::AttributeList::TypeInfo {
  static constexpr ClusterId GetClusterId() {
    return Clusters::UnitTesting::Id;
  }
};
} // namespace AttributeList
namespace FeatureMap {
struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo {
  static constexpr ClusterId GetClusterId() {
    return Clusters::UnitTesting::Id;
  }
};
} // namespace FeatureMap
namespace ClusterRevision {
struct TypeInfo
    : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo {
  static constexpr ClusterId GetClusterId() {
    return Clusters::UnitTesting::Id;
  }
};
} // namespace ClusterRevision
namespace MeiInt8u {
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::MeiInt8u::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace MeiInt8u

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

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

    Attributes::Boolean::TypeInfo::DecodableType boolean = static_cast<bool>(0);
    Attributes::Bitmap8::TypeInfo::DecodableType bitmap8 = static_cast<
        chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>(0);
    Attributes::Bitmap16::TypeInfo::DecodableType bitmap16 = static_cast<
        chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>(0);
    Attributes::Bitmap32::TypeInfo::DecodableType bitmap32 = static_cast<
        chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>(0);
    Attributes::Bitmap64::TypeInfo::DecodableType bitmap64 = static_cast<
        chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>(0);
    Attributes::Int8u::TypeInfo::DecodableType int8u = static_cast<uint8_t>(0);
    Attributes::Int16u::TypeInfo::DecodableType int16u =
        static_cast<uint16_t>(0);
    Attributes::Int24u::TypeInfo::DecodableType int24u =
        static_cast<uint32_t>(0);
    Attributes::Int32u::TypeInfo::DecodableType int32u =
        static_cast<uint32_t>(0);
    Attributes::Int40u::TypeInfo::DecodableType int40u =
        static_cast<uint64_t>(0);
    Attributes::Int48u::TypeInfo::DecodableType int48u =
        static_cast<uint64_t>(0);
    Attributes::Int56u::TypeInfo::DecodableType int56u =
        static_cast<uint64_t>(0);
    Attributes::Int64u::TypeInfo::DecodableType int64u =
        static_cast<uint64_t>(0);
    Attributes::Int8s::TypeInfo::DecodableType int8s = static_cast<int8_t>(0);
    Attributes::Int16s::TypeInfo::DecodableType int16s =
        static_cast<int16_t>(0);
    Attributes::Int24s::TypeInfo::DecodableType int24s =
        static_cast<int32_t>(0);
    Attributes::Int32s::TypeInfo::DecodableType int32s =
        static_cast<int32_t>(0);
    Attributes::Int40s::TypeInfo::DecodableType int40s =
        static_cast<int64_t>(0);
    Attributes::Int48s::TypeInfo::DecodableType int48s =
        static_cast<int64_t>(0);
    Attributes::Int56s::TypeInfo::DecodableType int56s =
        static_cast<int64_t>(0);
    Attributes::Int64s::TypeInfo::DecodableType int64s =
        static_cast<int64_t>(0);
    Attributes::Enum8::TypeInfo::DecodableType enum8 = static_cast<uint8_t>(0);
    Attributes::Enum16::TypeInfo::DecodableType enum16 =
        static_cast<uint16_t>(0);
    Attributes::FloatSingle::TypeInfo::DecodableType floatSingle =
        static_cast<float>(0);
    Attributes::FloatDouble::TypeInfo::DecodableType floatDouble =
        static_cast<double>(0);
    Attributes::OctetString::TypeInfo::DecodableType octetString;
    Attributes::ListInt8u::TypeInfo::DecodableType listInt8u;
    Attributes::ListOctetString::TypeInfo::DecodableType listOctetString;
    Attributes::ListStructOctetString::TypeInfo::DecodableType
        listStructOctetString;
    Attributes::LongOctetString::TypeInfo::DecodableType longOctetString;
    Attributes::CharString::TypeInfo::DecodableType charString;
    Attributes::LongCharString::TypeInfo::DecodableType longCharString;
    Attributes::EpochUs::TypeInfo::DecodableType epochUs =
        static_cast<uint64_t>(0);
    Attributes::EpochS::TypeInfo::DecodableType epochS =
        static_cast<uint32_t>(0);
    Attributes::VendorId::TypeInfo::DecodableType vendorId =
        static_cast<chip::VendorId>(0);
    Attributes::ListNullablesAndOptionalsStruct::TypeInfo::DecodableType
        listNullablesAndOptionalsStruct;
    Attributes::EnumAttr::TypeInfo::DecodableType enumAttr =
        static_cast<chip::app::Clusters::UnitTesting::SimpleEnum>(0);
    Attributes::StructAttr::TypeInfo::DecodableType structAttr;
    Attributes::RangeRestrictedInt8u::TypeInfo::DecodableType
        rangeRestrictedInt8u = static_cast<uint8_t>(0);
    Attributes::RangeRestrictedInt8s::TypeInfo::DecodableType
        rangeRestrictedInt8s = static_cast<int8_t>(0);
    Attributes::RangeRestrictedInt16u::TypeInfo::DecodableType
        rangeRestrictedInt16u = static_cast<uint16_t>(0);
    Attributes::RangeRestrictedInt16s::TypeInfo::DecodableType
        rangeRestrictedInt16s = static_cast<int16_t>(0);
    Attributes::ListLongOctetString::TypeInfo::DecodableType
        listLongOctetString;
    Attributes::ListFabricScoped::TypeInfo::DecodableType listFabricScoped;
    Attributes::TimedWriteBoolean::TypeInfo::DecodableType timedWriteBoolean =
        static_cast<bool>(0);
    Attributes::GeneralErrorBoolean::TypeInfo::DecodableType
        generalErrorBoolean = static_cast<bool>(0);
    Attributes::ClusterErrorBoolean::TypeInfo::DecodableType
        clusterErrorBoolean = static_cast<bool>(0);
    Attributes::GlobalEnum::TypeInfo::DecodableType globalEnum =
        static_cast<chip::app::Clusters::Globals::TestGlobalEnum>(0);
    Attributes::GlobalStruct::TypeInfo::DecodableType globalStruct;
    Attributes::Unsupported::TypeInfo::DecodableType unsupported =
        static_cast<bool>(0);
    Attributes::ReadFailureCode::TypeInfo::DecodableType readFailureCode =
        static_cast<uint8_t>(0);
    Attributes::FailureInt32U::TypeInfo::DecodableType failureInt32U =
        static_cast<uint32_t>(0);
    Attributes::NullableBoolean::TypeInfo::DecodableType nullableBoolean;
    Attributes::NullableBitmap8::TypeInfo::DecodableType nullableBitmap8;
    Attributes::NullableBitmap16::TypeInfo::DecodableType nullableBitmap16;
    Attributes::NullableBitmap32::TypeInfo::DecodableType nullableBitmap32;
    Attributes::NullableBitmap64::TypeInfo::DecodableType nullableBitmap64;
    Attributes::NullableInt8u::TypeInfo::DecodableType nullableInt8u;
    Attributes::NullableInt16u::TypeInfo::DecodableType nullableInt16u;
    Attributes::NullableInt24u::TypeInfo::DecodableType nullableInt24u;
    Attributes::NullableInt32u::TypeInfo::DecodableType nullableInt32u;
    Attributes::NullableInt40u::TypeInfo::DecodableType nullableInt40u;
    Attributes::NullableInt48u::TypeInfo::DecodableType nullableInt48u;
    Attributes::NullableInt56u::TypeInfo::DecodableType nullableInt56u;
    Attributes::NullableInt64u::TypeInfo::DecodableType nullableInt64u;
    Attributes::NullableInt8s::TypeInfo::DecodableType nullableInt8s;
    Attributes::NullableInt16s::TypeInfo::DecodableType nullableInt16s;
    Attributes::NullableInt24s::TypeInfo::DecodableType nullableInt24s;
    Attributes::NullableInt32s::TypeInfo::DecodableType nullableInt32s;
    Attributes::NullableInt40s::TypeInfo::DecodableType nullableInt40s;
    Attributes::NullableInt48s::TypeInfo::DecodableType nullableInt48s;
    Attributes::NullableInt56s::TypeInfo::DecodableType nullableInt56s;
    Attributes::NullableInt64s::TypeInfo::DecodableType nullableInt64s;
    Attributes::NullableEnum8::TypeInfo::DecodableType nullableEnum8;
    Attributes::NullableEnum16::TypeInfo::DecodableType nullableEnum16;
    Attributes::NullableFloatSingle::TypeInfo::DecodableType
        nullableFloatSingle;
    Attributes::NullableFloatDouble::TypeInfo::DecodableType
        nullableFloatDouble;
    Attributes::NullableOctetString::TypeInfo::DecodableType
        nullableOctetString;
    Attributes::NullableCharString::TypeInfo::DecodableType nullableCharString;
    Attributes::NullableEnumAttr::TypeInfo::DecodableType nullableEnumAttr;
    Attributes::NullableStruct::TypeInfo::DecodableType nullableStruct;
    Attributes::NullableRangeRestrictedInt8u::TypeInfo::DecodableType
        nullableRangeRestrictedInt8u;
    Attributes::NullableRangeRestrictedInt8s::TypeInfo::DecodableType
        nullableRangeRestrictedInt8s;
    Attributes::NullableRangeRestrictedInt16u::TypeInfo::DecodableType
        nullableRangeRestrictedInt16u;
    Attributes::NullableRangeRestrictedInt16s::TypeInfo::DecodableType
        nullableRangeRestrictedInt16s;
    Attributes::WriteOnlyInt8u::TypeInfo::DecodableType writeOnlyInt8u =
        static_cast<uint8_t>(0);
    Attributes::NullableGlobalEnum::TypeInfo::DecodableType nullableGlobalEnum;
    Attributes::NullableGlobalStruct::TypeInfo::DecodableType
        nullableGlobalStruct;
    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);
    Attributes::MeiInt8u::TypeInfo::DecodableType meiInt8u =
        static_cast<uint8_t>(0);
  };
};
} // namespace Attributes
} // namespace UnitTesting
} // namespace Clusters
} // namespace app
} // namespace chip
