/*
 *
 *    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/DoorLock/AttributeIds.h>
#include <clusters/DoorLock/ClusterId.h>
#include <clusters/DoorLock/Enums.h>
#include <clusters/DoorLock/Structs.h>

namespace chip {
namespace app {
namespace Clusters {
namespace DoorLock {
namespace Attributes {

namespace LockState {
struct TypeInfo {
  using Type = chip::app::DataModel::Nullable<
      chip::app::Clusters::DoorLock::DlLockState>;
  using DecodableType = chip::app::DataModel::Nullable<
      chip::app::Clusters::DoorLock::DlLockState>;
  using DecodableArgType = const chip::app::DataModel::Nullable<
      chip::app::Clusters::DoorLock::DlLockState> &;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::LockState::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace LockState
namespace LockType {
struct TypeInfo {
  using Type = chip::app::Clusters::DoorLock::DlLockType;
  using DecodableType = chip::app::Clusters::DoorLock::DlLockType;
  using DecodableArgType = chip::app::Clusters::DoorLock::DlLockType;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::LockType::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace LockType
namespace ActuatorEnabled {
struct TypeInfo {
  using Type = bool;
  using DecodableType = bool;
  using DecodableArgType = bool;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::ActuatorEnabled::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace ActuatorEnabled
namespace DoorState {
struct TypeInfo {
  using Type = chip::app::DataModel::Nullable<
      chip::app::Clusters::DoorLock::DoorStateEnum>;
  using DecodableType = chip::app::DataModel::Nullable<
      chip::app::Clusters::DoorLock::DoorStateEnum>;
  using DecodableArgType = const chip::app::DataModel::Nullable<
      chip::app::Clusters::DoorLock::DoorStateEnum> &;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::DoorState::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace DoorState
namespace DoorOpenEvents {
struct TypeInfo {
  using Type = uint32_t;
  using DecodableType = uint32_t;
  using DecodableArgType = uint32_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::DoorOpenEvents::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace DoorOpenEvents
namespace DoorClosedEvents {
struct TypeInfo {
  using Type = uint32_t;
  using DecodableType = uint32_t;
  using DecodableArgType = uint32_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::DoorClosedEvents::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace DoorClosedEvents
namespace OpenPeriod {
struct TypeInfo {
  using Type = uint16_t;
  using DecodableType = uint16_t;
  using DecodableArgType = uint16_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::OpenPeriod::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace OpenPeriod
namespace NumberOfTotalUsersSupported {
struct TypeInfo {
  using Type = uint16_t;
  using DecodableType = uint16_t;
  using DecodableArgType = uint16_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfTotalUsersSupported::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfTotalUsersSupported
namespace NumberOfPINUsersSupported {
struct TypeInfo {
  using Type = uint16_t;
  using DecodableType = uint16_t;
  using DecodableArgType = uint16_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfPINUsersSupported::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfPINUsersSupported
namespace NumberOfRFIDUsersSupported {
struct TypeInfo {
  using Type = uint16_t;
  using DecodableType = uint16_t;
  using DecodableArgType = uint16_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfRFIDUsersSupported::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfRFIDUsersSupported
namespace NumberOfWeekDaySchedulesSupportedPerUser {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfWeekDaySchedulesSupportedPerUser
namespace NumberOfYearDaySchedulesSupportedPerUser {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfYearDaySchedulesSupportedPerUser
namespace NumberOfHolidaySchedulesSupported {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfHolidaySchedulesSupported::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfHolidaySchedulesSupported
namespace MaxPINCodeLength {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::MaxPINCodeLength::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace MaxPINCodeLength
namespace MinPINCodeLength {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::MinPINCodeLength::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace MinPINCodeLength
namespace MaxRFIDCodeLength {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::MaxRFIDCodeLength::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace MaxRFIDCodeLength
namespace MinRFIDCodeLength {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::MinRFIDCodeLength::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace MinRFIDCodeLength
namespace CredentialRulesSupport {
struct TypeInfo {
  using Type =
      chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>;
  using DecodableType =
      chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>;
  using DecodableArgType =
      chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::CredentialRulesSupport::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace CredentialRulesSupport
namespace NumberOfCredentialsSupportedPerUser {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfCredentialsSupportedPerUser::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfCredentialsSupportedPerUser
namespace Language {
struct TypeInfo {
  using Type = chip::CharSpan;
  using DecodableType = chip::CharSpan;
  using DecodableArgType = chip::CharSpan;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::Language::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
  static constexpr size_t MaxLength() { return 3; }
};
} // namespace Language
namespace LEDSettings {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::LEDSettings::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace LEDSettings
namespace AutoRelockTime {
struct TypeInfo {
  using Type = uint32_t;
  using DecodableType = uint32_t;
  using DecodableArgType = uint32_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::AutoRelockTime::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace AutoRelockTime
namespace SoundVolume {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::SoundVolume::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace SoundVolume
namespace OperatingMode {
struct TypeInfo {
  using Type = chip::app::Clusters::DoorLock::OperatingModeEnum;
  using DecodableType = chip::app::Clusters::DoorLock::OperatingModeEnum;
  using DecodableArgType = chip::app::Clusters::DoorLock::OperatingModeEnum;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::OperatingMode::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace OperatingMode
namespace SupportedOperatingModes {
struct TypeInfo {
  using Type =
      chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>;
  using DecodableType =
      chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>;
  using DecodableArgType =
      chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::SupportedOperatingModes::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace SupportedOperatingModes
namespace DefaultConfigurationRegister {
struct TypeInfo {
  using Type = chip::BitMask<
      chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>;
  using DecodableType = chip::BitMask<
      chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>;
  using DecodableArgType = chip::BitMask<
      chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::DefaultConfigurationRegister::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace DefaultConfigurationRegister
namespace EnableLocalProgramming {
struct TypeInfo {
  using Type = bool;
  using DecodableType = bool;
  using DecodableArgType = bool;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::EnableLocalProgramming::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace EnableLocalProgramming
namespace EnableOneTouchLocking {
struct TypeInfo {
  using Type = bool;
  using DecodableType = bool;
  using DecodableArgType = bool;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::EnableOneTouchLocking::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace EnableOneTouchLocking
namespace EnableInsideStatusLED {
struct TypeInfo {
  using Type = bool;
  using DecodableType = bool;
  using DecodableArgType = bool;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::EnableInsideStatusLED::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace EnableInsideStatusLED
namespace EnablePrivacyModeButton {
struct TypeInfo {
  using Type = bool;
  using DecodableType = bool;
  using DecodableArgType = bool;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::EnablePrivacyModeButton::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace EnablePrivacyModeButton
namespace LocalProgrammingFeatures {
struct TypeInfo {
  using Type =
      chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>;
  using DecodableType =
      chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>;
  using DecodableArgType =
      chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::LocalProgrammingFeatures::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace LocalProgrammingFeatures
namespace WrongCodeEntryLimit {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::WrongCodeEntryLimit::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace WrongCodeEntryLimit
namespace UserCodeTemporaryDisableTime {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::UserCodeTemporaryDisableTime::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace UserCodeTemporaryDisableTime
namespace SendPINOverTheAir {
struct TypeInfo {
  using Type = bool;
  using DecodableType = bool;
  using DecodableArgType = bool;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::SendPINOverTheAir::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace SendPINOverTheAir
namespace RequirePINforRemoteOperation {
struct TypeInfo {
  using Type = bool;
  using DecodableType = bool;
  using DecodableArgType = bool;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::RequirePINforRemoteOperation::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace RequirePINforRemoteOperation
namespace ExpiringUserTimeout {
struct TypeInfo {
  using Type = uint16_t;
  using DecodableType = uint16_t;
  using DecodableArgType = uint16_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::ExpiringUserTimeout::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace ExpiringUserTimeout
namespace AliroReaderVerificationKey {
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::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::AliroReaderVerificationKey::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
  static constexpr size_t MaxLength() { return 65; }
};
} // namespace AliroReaderVerificationKey
namespace AliroReaderGroupIdentifier {
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::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::AliroReaderGroupIdentifier::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
  static constexpr size_t MaxLength() { return 16; }
};
} // namespace AliroReaderGroupIdentifier
namespace AliroReaderGroupSubIdentifier {
struct TypeInfo {
  using Type = chip::ByteSpan;
  using DecodableType = chip::ByteSpan;
  using DecodableArgType = chip::ByteSpan;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::AliroReaderGroupSubIdentifier::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
  static constexpr size_t MaxLength() { return 16; }
};
} // namespace AliroReaderGroupSubIdentifier
namespace AliroExpeditedTransactionSupportedProtocolVersions {
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::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::AliroExpeditedTransactionSupportedProtocolVersions::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace AliroExpeditedTransactionSupportedProtocolVersions
namespace AliroGroupResolvingKey {
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::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::AliroGroupResolvingKey::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
  static constexpr size_t MaxLength() { return 16; }
};
} // namespace AliroGroupResolvingKey
namespace AliroSupportedBLEUWBProtocolVersions {
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::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::AliroSupportedBLEUWBProtocolVersions::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace AliroSupportedBLEUWBProtocolVersions
namespace AliroBLEAdvertisingVersion {
struct TypeInfo {
  using Type = uint8_t;
  using DecodableType = uint8_t;
  using DecodableArgType = uint8_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::AliroBLEAdvertisingVersion::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace AliroBLEAdvertisingVersion
namespace NumberOfAliroCredentialIssuerKeysSupported {
struct TypeInfo {
  using Type = uint16_t;
  using DecodableType = uint16_t;
  using DecodableArgType = uint16_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfAliroCredentialIssuerKeysSupported::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfAliroCredentialIssuerKeysSupported
namespace NumberOfAliroEndpointKeysSupported {
struct TypeInfo {
  using Type = uint16_t;
  using DecodableType = uint16_t;
  using DecodableArgType = uint16_t;

  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
  static constexpr AttributeId GetAttributeId() {
    return Attributes::NumberOfAliroEndpointKeysSupported::Id;
  }
  static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace NumberOfAliroEndpointKeysSupported
namespace GeneratedCommandList {
struct TypeInfo
    : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo {
  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
};
} // namespace GeneratedCommandList
namespace AcceptedCommandList {
struct TypeInfo
    : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo {
  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
};
} // namespace AcceptedCommandList
namespace AttributeList {
struct TypeInfo
    : public Clusters::Globals::Attributes::AttributeList::TypeInfo {
  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
};
} // namespace AttributeList
namespace FeatureMap {
struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo {
  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
};
} // namespace FeatureMap
namespace ClusterRevision {
struct TypeInfo
    : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo {
  static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
};
} // namespace ClusterRevision

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

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

    Attributes::LockState::TypeInfo::DecodableType lockState;
    Attributes::LockType::TypeInfo::DecodableType lockType =
        static_cast<chip::app::Clusters::DoorLock::DlLockType>(0);
    Attributes::ActuatorEnabled::TypeInfo::DecodableType actuatorEnabled =
        static_cast<bool>(0);
    Attributes::DoorState::TypeInfo::DecodableType doorState;
    Attributes::DoorOpenEvents::TypeInfo::DecodableType doorOpenEvents =
        static_cast<uint32_t>(0);
    Attributes::DoorClosedEvents::TypeInfo::DecodableType doorClosedEvents =
        static_cast<uint32_t>(0);
    Attributes::OpenPeriod::TypeInfo::DecodableType openPeriod =
        static_cast<uint16_t>(0);
    Attributes::NumberOfTotalUsersSupported::TypeInfo::DecodableType
        numberOfTotalUsersSupported = static_cast<uint16_t>(0);
    Attributes::NumberOfPINUsersSupported::TypeInfo::DecodableType
        numberOfPINUsersSupported = static_cast<uint16_t>(0);
    Attributes::NumberOfRFIDUsersSupported::TypeInfo::DecodableType
        numberOfRFIDUsersSupported = static_cast<uint16_t>(0);
    Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo::
        DecodableType numberOfWeekDaySchedulesSupportedPerUser =
            static_cast<uint8_t>(0);
    Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo::
        DecodableType numberOfYearDaySchedulesSupportedPerUser =
            static_cast<uint8_t>(0);
    Attributes::NumberOfHolidaySchedulesSupported::TypeInfo::DecodableType
        numberOfHolidaySchedulesSupported = static_cast<uint8_t>(0);
    Attributes::MaxPINCodeLength::TypeInfo::DecodableType maxPINCodeLength =
        static_cast<uint8_t>(0);
    Attributes::MinPINCodeLength::TypeInfo::DecodableType minPINCodeLength =
        static_cast<uint8_t>(0);
    Attributes::MaxRFIDCodeLength::TypeInfo::DecodableType maxRFIDCodeLength =
        static_cast<uint8_t>(0);
    Attributes::MinRFIDCodeLength::TypeInfo::DecodableType minRFIDCodeLength =
        static_cast<uint8_t>(0);
    Attributes::CredentialRulesSupport::TypeInfo::DecodableType
        credentialRulesSupport = static_cast<
            chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>>(
            0);
    Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo::DecodableType
        numberOfCredentialsSupportedPerUser = static_cast<uint8_t>(0);
    Attributes::Language::TypeInfo::DecodableType language;
    Attributes::LEDSettings::TypeInfo::DecodableType LEDSettings =
        static_cast<uint8_t>(0);
    Attributes::AutoRelockTime::TypeInfo::DecodableType autoRelockTime =
        static_cast<uint32_t>(0);
    Attributes::SoundVolume::TypeInfo::DecodableType soundVolume =
        static_cast<uint8_t>(0);
    Attributes::OperatingMode::TypeInfo::DecodableType operatingMode =
        static_cast<chip::app::Clusters::DoorLock::OperatingModeEnum>(0);
    Attributes::SupportedOperatingModes::TypeInfo::DecodableType
        supportedOperatingModes = static_cast<chip::BitMask<
            chip::app::Clusters::DoorLock::DlSupportedOperatingModes>>(0);
    Attributes::DefaultConfigurationRegister::TypeInfo::DecodableType
        defaultConfigurationRegister = static_cast<chip::BitMask<
            chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>>(0);
    Attributes::EnableLocalProgramming::TypeInfo::DecodableType
        enableLocalProgramming = static_cast<bool>(0);
    Attributes::EnableOneTouchLocking::TypeInfo::DecodableType
        enableOneTouchLocking = static_cast<bool>(0);
    Attributes::EnableInsideStatusLED::TypeInfo::DecodableType
        enableInsideStatusLED = static_cast<bool>(0);
    Attributes::EnablePrivacyModeButton::TypeInfo::DecodableType
        enablePrivacyModeButton = static_cast<bool>(0);
    Attributes::LocalProgrammingFeatures::TypeInfo::DecodableType
        localProgrammingFeatures = static_cast<chip::BitMask<
            chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>>(0);
    Attributes::WrongCodeEntryLimit::TypeInfo::DecodableType
        wrongCodeEntryLimit = static_cast<uint8_t>(0);
    Attributes::UserCodeTemporaryDisableTime::TypeInfo::DecodableType
        userCodeTemporaryDisableTime = static_cast<uint8_t>(0);
    Attributes::SendPINOverTheAir::TypeInfo::DecodableType sendPINOverTheAir =
        static_cast<bool>(0);
    Attributes::RequirePINforRemoteOperation::TypeInfo::DecodableType
        requirePINforRemoteOperation = static_cast<bool>(0);
    Attributes::ExpiringUserTimeout::TypeInfo::DecodableType
        expiringUserTimeout = static_cast<uint16_t>(0);
    Attributes::AliroReaderVerificationKey::TypeInfo::DecodableType
        aliroReaderVerificationKey;
    Attributes::AliroReaderGroupIdentifier::TypeInfo::DecodableType
        aliroReaderGroupIdentifier;
    Attributes::AliroReaderGroupSubIdentifier::TypeInfo::DecodableType
        aliroReaderGroupSubIdentifier;
    Attributes::AliroExpeditedTransactionSupportedProtocolVersions::TypeInfo::
        DecodableType aliroExpeditedTransactionSupportedProtocolVersions;
    Attributes::AliroGroupResolvingKey::TypeInfo::DecodableType
        aliroGroupResolvingKey;
    Attributes::AliroSupportedBLEUWBProtocolVersions::TypeInfo::DecodableType
        aliroSupportedBLEUWBProtocolVersions;
    Attributes::AliroBLEAdvertisingVersion::TypeInfo::DecodableType
        aliroBLEAdvertisingVersion = static_cast<uint8_t>(0);
    Attributes::NumberOfAliroCredentialIssuerKeysSupported::TypeInfo::
        DecodableType numberOfAliroCredentialIssuerKeysSupported =
            static_cast<uint16_t>(0);
    Attributes::NumberOfAliroEndpointKeysSupported::TypeInfo::DecodableType
        numberOfAliroEndpointKeysSupported = static_cast<uint16_t>(0);
    Attributes::GeneratedCommandList::TypeInfo::DecodableType
        generatedCommandList;
    Attributes::AcceptedCommandList::TypeInfo::DecodableType
        acceptedCommandList;
    Attributes::AttributeList::TypeInfo::DecodableType attributeList;
    Attributes::FeatureMap::TypeInfo::DecodableType featureMap =
        static_cast<uint32_t>(0);
    Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision =
        static_cast<uint16_t>(0);
  };
};
} // namespace Attributes
} // namespace DoorLock
} // namespace Clusters
} // namespace app
} // namespace chip
