// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: keyapis/access_control/v1/keyapis_access_control_entrance_v1.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4023000
#error "This file was generated by a newer version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please update"
#error "your headers."
#endif  // PROTOBUF_VERSION

#if 4023001 < PROTOBUF_MIN_PROTOC_VERSION
#error "This file was generated by an older version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please"
#error "regenerate this file with a newer version of protoc."
#endif  // PROTOBUF_MIN_PROTOC_VERSION
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_util.h"
#include "google/api/annotations.pb.h"
#include "google/api/field_behavior.pb.h"
#include "keyapis/access_control/v1/keyapis_access_control_access_control_v1.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto

PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto {
  static const ::uint32_t offsets[];
};
namespace keyapis {
namespace access_control {
namespace v1 {
class DeleteEntranceRequest;
struct DeleteEntranceRequestDefaultTypeInternal;
extern DeleteEntranceRequestDefaultTypeInternal _DeleteEntranceRequest_default_instance_;
class DeleteEntranceResponse;
struct DeleteEntranceResponseDefaultTypeInternal;
extern DeleteEntranceResponseDefaultTypeInternal _DeleteEntranceResponse_default_instance_;
class DeleteEntranceResponse_Error;
struct DeleteEntranceResponse_ErrorDefaultTypeInternal;
extern DeleteEntranceResponse_ErrorDefaultTypeInternal _DeleteEntranceResponse_Error_default_instance_;
class DeleteEntranceResponse_Error_LinkedDevicesExists;
struct DeleteEntranceResponse_Error_LinkedDevicesExistsDefaultTypeInternal;
extern DeleteEntranceResponse_Error_LinkedDevicesExistsDefaultTypeInternal _DeleteEntranceResponse_Error_LinkedDevicesExists_default_instance_;
class Entrance;
struct EntranceDefaultTypeInternal;
extern EntranceDefaultTypeInternal _Entrance_default_instance_;
class EntranceDevice;
struct EntranceDeviceDefaultTypeInternal;
extern EntranceDeviceDefaultTypeInternal _EntranceDevice_default_instance_;
class EntranceDeviceFilter;
struct EntranceDeviceFilterDefaultTypeInternal;
extern EntranceDeviceFilterDefaultTypeInternal _EntranceDeviceFilter_default_instance_;
class EntranceDevicePaging;
struct EntranceDevicePagingDefaultTypeInternal;
extern EntranceDevicePagingDefaultTypeInternal _EntranceDevicePaging_default_instance_;
class EntranceFilter;
struct EntranceFilterDefaultTypeInternal;
extern EntranceFilterDefaultTypeInternal _EntranceFilter_default_instance_;
class EntrancePaging;
struct EntrancePagingDefaultTypeInternal;
extern EntrancePagingDefaultTypeInternal _EntrancePaging_default_instance_;
class GetEntranceDeviceListRequest;
struct GetEntranceDeviceListRequestDefaultTypeInternal;
extern GetEntranceDeviceListRequestDefaultTypeInternal _GetEntranceDeviceListRequest_default_instance_;
class GetEntranceDeviceListResponse;
struct GetEntranceDeviceListResponseDefaultTypeInternal;
extern GetEntranceDeviceListResponseDefaultTypeInternal _GetEntranceDeviceListResponse_default_instance_;
class GetEntranceDeviceListResponse_Error;
struct GetEntranceDeviceListResponse_ErrorDefaultTypeInternal;
extern GetEntranceDeviceListResponse_ErrorDefaultTypeInternal _GetEntranceDeviceListResponse_Error_default_instance_;
class GetEntranceListRequest;
struct GetEntranceListRequestDefaultTypeInternal;
extern GetEntranceListRequestDefaultTypeInternal _GetEntranceListRequest_default_instance_;
class GetEntranceListResponse;
struct GetEntranceListResponseDefaultTypeInternal;
extern GetEntranceListResponseDefaultTypeInternal _GetEntranceListResponse_default_instance_;
class GetEntranceListResponse_Error;
struct GetEntranceListResponse_ErrorDefaultTypeInternal;
extern GetEntranceListResponse_ErrorDefaultTypeInternal _GetEntranceListResponse_Error_default_instance_;
class PostEntranceRequest;
struct PostEntranceRequestDefaultTypeInternal;
extern PostEntranceRequestDefaultTypeInternal _PostEntranceRequest_default_instance_;
class PostEntranceResponse;
struct PostEntranceResponseDefaultTypeInternal;
extern PostEntranceResponseDefaultTypeInternal _PostEntranceResponse_default_instance_;
class PostEntranceResponse_Error;
struct PostEntranceResponse_ErrorDefaultTypeInternal;
extern PostEntranceResponse_ErrorDefaultTypeInternal _PostEntranceResponse_Error_default_instance_;
class PutEntranceDeviceAttachRequest;
struct PutEntranceDeviceAttachRequestDefaultTypeInternal;
extern PutEntranceDeviceAttachRequestDefaultTypeInternal _PutEntranceDeviceAttachRequest_default_instance_;
class PutEntranceDeviceAttachResponse;
struct PutEntranceDeviceAttachResponseDefaultTypeInternal;
extern PutEntranceDeviceAttachResponseDefaultTypeInternal _PutEntranceDeviceAttachResponse_default_instance_;
class PutEntranceDeviceAttachResponse_Error;
struct PutEntranceDeviceAttachResponse_ErrorDefaultTypeInternal;
extern PutEntranceDeviceAttachResponse_ErrorDefaultTypeInternal _PutEntranceDeviceAttachResponse_Error_default_instance_;
class PutEntranceDeviceDetachRequest;
struct PutEntranceDeviceDetachRequestDefaultTypeInternal;
extern PutEntranceDeviceDetachRequestDefaultTypeInternal _PutEntranceDeviceDetachRequest_default_instance_;
class PutEntranceDeviceDetachResponse;
struct PutEntranceDeviceDetachResponseDefaultTypeInternal;
extern PutEntranceDeviceDetachResponseDefaultTypeInternal _PutEntranceDeviceDetachResponse_default_instance_;
class PutEntranceDeviceDetachResponse_Error;
struct PutEntranceDeviceDetachResponse_ErrorDefaultTypeInternal;
extern PutEntranceDeviceDetachResponse_ErrorDefaultTypeInternal _PutEntranceDeviceDetachResponse_Error_default_instance_;
}  // namespace v1
}  // namespace access_control
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template <>
::keyapis::access_control::v1::DeleteEntranceRequest* Arena::CreateMaybeMessage<::keyapis::access_control::v1::DeleteEntranceRequest>(Arena*);
template <>
::keyapis::access_control::v1::DeleteEntranceResponse* Arena::CreateMaybeMessage<::keyapis::access_control::v1::DeleteEntranceResponse>(Arena*);
template <>
::keyapis::access_control::v1::DeleteEntranceResponse_Error* Arena::CreateMaybeMessage<::keyapis::access_control::v1::DeleteEntranceResponse_Error>(Arena*);
template <>
::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* Arena::CreateMaybeMessage<::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists>(Arena*);
template <>
::keyapis::access_control::v1::Entrance* Arena::CreateMaybeMessage<::keyapis::access_control::v1::Entrance>(Arena*);
template <>
::keyapis::access_control::v1::EntranceDevice* Arena::CreateMaybeMessage<::keyapis::access_control::v1::EntranceDevice>(Arena*);
template <>
::keyapis::access_control::v1::EntranceDeviceFilter* Arena::CreateMaybeMessage<::keyapis::access_control::v1::EntranceDeviceFilter>(Arena*);
template <>
::keyapis::access_control::v1::EntranceDevicePaging* Arena::CreateMaybeMessage<::keyapis::access_control::v1::EntranceDevicePaging>(Arena*);
template <>
::keyapis::access_control::v1::EntranceFilter* Arena::CreateMaybeMessage<::keyapis::access_control::v1::EntranceFilter>(Arena*);
template <>
::keyapis::access_control::v1::EntrancePaging* Arena::CreateMaybeMessage<::keyapis::access_control::v1::EntrancePaging>(Arena*);
template <>
::keyapis::access_control::v1::GetEntranceDeviceListRequest* Arena::CreateMaybeMessage<::keyapis::access_control::v1::GetEntranceDeviceListRequest>(Arena*);
template <>
::keyapis::access_control::v1::GetEntranceDeviceListResponse* Arena::CreateMaybeMessage<::keyapis::access_control::v1::GetEntranceDeviceListResponse>(Arena*);
template <>
::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* Arena::CreateMaybeMessage<::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error>(Arena*);
template <>
::keyapis::access_control::v1::GetEntranceListRequest* Arena::CreateMaybeMessage<::keyapis::access_control::v1::GetEntranceListRequest>(Arena*);
template <>
::keyapis::access_control::v1::GetEntranceListResponse* Arena::CreateMaybeMessage<::keyapis::access_control::v1::GetEntranceListResponse>(Arena*);
template <>
::keyapis::access_control::v1::GetEntranceListResponse_Error* Arena::CreateMaybeMessage<::keyapis::access_control::v1::GetEntranceListResponse_Error>(Arena*);
template <>
::keyapis::access_control::v1::PostEntranceRequest* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PostEntranceRequest>(Arena*);
template <>
::keyapis::access_control::v1::PostEntranceResponse* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PostEntranceResponse>(Arena*);
template <>
::keyapis::access_control::v1::PostEntranceResponse_Error* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PostEntranceResponse_Error>(Arena*);
template <>
::keyapis::access_control::v1::PutEntranceDeviceAttachRequest* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PutEntranceDeviceAttachRequest>(Arena*);
template <>
::keyapis::access_control::v1::PutEntranceDeviceAttachResponse* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PutEntranceDeviceAttachResponse>(Arena*);
template <>
::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error>(Arena*);
template <>
::keyapis::access_control::v1::PutEntranceDeviceDetachRequest* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PutEntranceDeviceDetachRequest>(Arena*);
template <>
::keyapis::access_control::v1::PutEntranceDeviceDetachResponse* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PutEntranceDeviceDetachResponse>(Arena*);
template <>
::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* Arena::CreateMaybeMessage<::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace keyapis {
namespace access_control {
namespace v1 {
enum EntranceFilter_CompanyRelationType : int {
  EntranceFilter_CompanyRelationType_COMPANY_RELATION_TYPE_UNKNOWN = 0,
  EntranceFilter_CompanyRelationType_DEFAULT = 1,
  EntranceFilter_CompanyRelationType_MANAGEMENT = 2,
  EntranceFilter_CompanyRelationType_DEVICE_SERVICE = 3,
  EntranceFilter_CompanyRelationType_EntranceFilter_CompanyRelationType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  EntranceFilter_CompanyRelationType_EntranceFilter_CompanyRelationType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool EntranceFilter_CompanyRelationType_IsValid(int value);
constexpr EntranceFilter_CompanyRelationType EntranceFilter_CompanyRelationType_CompanyRelationType_MIN = static_cast<EntranceFilter_CompanyRelationType>(0);
constexpr EntranceFilter_CompanyRelationType EntranceFilter_CompanyRelationType_CompanyRelationType_MAX = static_cast<EntranceFilter_CompanyRelationType>(3);
constexpr int EntranceFilter_CompanyRelationType_CompanyRelationType_ARRAYSIZE = 3 + 1;
const std::string& EntranceFilter_CompanyRelationType_Name(EntranceFilter_CompanyRelationType value);
template <typename T>
const std::string& EntranceFilter_CompanyRelationType_Name(T value) {
  static_assert(std::is_same<T, EntranceFilter_CompanyRelationType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to CompanyRelationType_Name().");
  return EntranceFilter_CompanyRelationType_Name(static_cast<EntranceFilter_CompanyRelationType>(value));
}
const std::string& EntranceFilter_CompanyRelationType_Name(EntranceFilter_CompanyRelationType value);
bool EntranceFilter_CompanyRelationType_Parse(absl::string_view name, EntranceFilter_CompanyRelationType* value);
enum EntrancePaging_OrderByType : int {
  EntrancePaging_OrderByType_ORDER_BY_TYPE_UNKNOWN = 0,
  EntrancePaging_OrderByType_ORPON_THEN_ENTRANCE_NUMBER = 1,
  EntrancePaging_OrderByType_EntrancePaging_OrderByType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  EntrancePaging_OrderByType_EntrancePaging_OrderByType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool EntrancePaging_OrderByType_IsValid(int value);
constexpr EntrancePaging_OrderByType EntrancePaging_OrderByType_OrderByType_MIN = static_cast<EntrancePaging_OrderByType>(0);
constexpr EntrancePaging_OrderByType EntrancePaging_OrderByType_OrderByType_MAX = static_cast<EntrancePaging_OrderByType>(1);
constexpr int EntrancePaging_OrderByType_OrderByType_ARRAYSIZE = 1 + 1;
const std::string& EntrancePaging_OrderByType_Name(EntrancePaging_OrderByType value);
template <typename T>
const std::string& EntrancePaging_OrderByType_Name(T value) {
  static_assert(std::is_same<T, EntrancePaging_OrderByType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to OrderByType_Name().");
  return EntrancePaging_OrderByType_Name(static_cast<EntrancePaging_OrderByType>(value));
}
const std::string& EntrancePaging_OrderByType_Name(EntrancePaging_OrderByType value);
bool EntrancePaging_OrderByType_Parse(absl::string_view name, EntrancePaging_OrderByType* value);
enum EntrancePaging_DirectionType : int {
  EntrancePaging_DirectionType_DIRECTION_TYPE_UNKNOWN = 0,
  EntrancePaging_DirectionType_DESC = 1,
  EntrancePaging_DirectionType_ASC = 2,
  EntrancePaging_DirectionType_EntrancePaging_DirectionType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  EntrancePaging_DirectionType_EntrancePaging_DirectionType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool EntrancePaging_DirectionType_IsValid(int value);
constexpr EntrancePaging_DirectionType EntrancePaging_DirectionType_DirectionType_MIN = static_cast<EntrancePaging_DirectionType>(0);
constexpr EntrancePaging_DirectionType EntrancePaging_DirectionType_DirectionType_MAX = static_cast<EntrancePaging_DirectionType>(2);
constexpr int EntrancePaging_DirectionType_DirectionType_ARRAYSIZE = 2 + 1;
const std::string& EntrancePaging_DirectionType_Name(EntrancePaging_DirectionType value);
template <typename T>
const std::string& EntrancePaging_DirectionType_Name(T value) {
  static_assert(std::is_same<T, EntrancePaging_DirectionType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to DirectionType_Name().");
  return EntrancePaging_DirectionType_Name(static_cast<EntrancePaging_DirectionType>(value));
}
const std::string& EntrancePaging_DirectionType_Name(EntrancePaging_DirectionType value);
bool EntrancePaging_DirectionType_Parse(absl::string_view name, EntrancePaging_DirectionType* value);
enum EntranceDevice_RelationType : int {
  EntranceDevice_RelationType_RELATION_TYPE_UNKNOWN = 0,
  EntranceDevice_RelationType_FULL = 1,
  EntranceDevice_RelationType_PARTIAL = 2,
  EntranceDevice_RelationType_EntranceDevice_RelationType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  EntranceDevice_RelationType_EntranceDevice_RelationType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool EntranceDevice_RelationType_IsValid(int value);
constexpr EntranceDevice_RelationType EntranceDevice_RelationType_RelationType_MIN = static_cast<EntranceDevice_RelationType>(0);
constexpr EntranceDevice_RelationType EntranceDevice_RelationType_RelationType_MAX = static_cast<EntranceDevice_RelationType>(2);
constexpr int EntranceDevice_RelationType_RelationType_ARRAYSIZE = 2 + 1;
const std::string& EntranceDevice_RelationType_Name(EntranceDevice_RelationType value);
template <typename T>
const std::string& EntranceDevice_RelationType_Name(T value) {
  static_assert(std::is_same<T, EntranceDevice_RelationType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to RelationType_Name().");
  return EntranceDevice_RelationType_Name(static_cast<EntranceDevice_RelationType>(value));
}
const std::string& EntranceDevice_RelationType_Name(EntranceDevice_RelationType value);
bool EntranceDevice_RelationType_Parse(absl::string_view name, EntranceDevice_RelationType* value);
enum EntranceDevicePaging_OrderByType : int {
  EntranceDevicePaging_OrderByType_ORDER_BY_TYPE_UNKNOWN = 0,
  EntranceDevicePaging_OrderByType_ORPON_THEN_ENTRANCE_NUMBER = 1,
  EntranceDevicePaging_OrderByType_DEVICE_ID = 2,
  EntranceDevicePaging_OrderByType_EntranceDevicePaging_OrderByType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  EntranceDevicePaging_OrderByType_EntranceDevicePaging_OrderByType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool EntranceDevicePaging_OrderByType_IsValid(int value);
constexpr EntranceDevicePaging_OrderByType EntranceDevicePaging_OrderByType_OrderByType_MIN = static_cast<EntranceDevicePaging_OrderByType>(0);
constexpr EntranceDevicePaging_OrderByType EntranceDevicePaging_OrderByType_OrderByType_MAX = static_cast<EntranceDevicePaging_OrderByType>(2);
constexpr int EntranceDevicePaging_OrderByType_OrderByType_ARRAYSIZE = 2 + 1;
const std::string& EntranceDevicePaging_OrderByType_Name(EntranceDevicePaging_OrderByType value);
template <typename T>
const std::string& EntranceDevicePaging_OrderByType_Name(T value) {
  static_assert(std::is_same<T, EntranceDevicePaging_OrderByType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to OrderByType_Name().");
  return EntranceDevicePaging_OrderByType_Name(static_cast<EntranceDevicePaging_OrderByType>(value));
}
const std::string& EntranceDevicePaging_OrderByType_Name(EntranceDevicePaging_OrderByType value);
bool EntranceDevicePaging_OrderByType_Parse(absl::string_view name, EntranceDevicePaging_OrderByType* value);
enum EntranceDevicePaging_DirectionType : int {
  EntranceDevicePaging_DirectionType_DIRECTION_TYPE_UNKNOWN = 0,
  EntranceDevicePaging_DirectionType_DESC = 1,
  EntranceDevicePaging_DirectionType_ASC = 2,
  EntranceDevicePaging_DirectionType_EntranceDevicePaging_DirectionType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  EntranceDevicePaging_DirectionType_EntranceDevicePaging_DirectionType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool EntranceDevicePaging_DirectionType_IsValid(int value);
constexpr EntranceDevicePaging_DirectionType EntranceDevicePaging_DirectionType_DirectionType_MIN = static_cast<EntranceDevicePaging_DirectionType>(0);
constexpr EntranceDevicePaging_DirectionType EntranceDevicePaging_DirectionType_DirectionType_MAX = static_cast<EntranceDevicePaging_DirectionType>(2);
constexpr int EntranceDevicePaging_DirectionType_DirectionType_ARRAYSIZE = 2 + 1;
const std::string& EntranceDevicePaging_DirectionType_Name(EntranceDevicePaging_DirectionType value);
template <typename T>
const std::string& EntranceDevicePaging_DirectionType_Name(T value) {
  static_assert(std::is_same<T, EntranceDevicePaging_DirectionType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to DirectionType_Name().");
  return EntranceDevicePaging_DirectionType_Name(static_cast<EntranceDevicePaging_DirectionType>(value));
}
const std::string& EntranceDevicePaging_DirectionType_Name(EntranceDevicePaging_DirectionType value);
bool EntranceDevicePaging_DirectionType_Parse(absl::string_view name, EntranceDevicePaging_DirectionType* value);

// ===================================================================


// -------------------------------------------------------------------

class Entrance final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.Entrance) */ {
 public:
  inline Entrance() : Entrance(nullptr) {}
  ~Entrance() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Entrance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Entrance(const Entrance& from);
  Entrance(Entrance&& from) noexcept
    : Entrance() {
    *this = ::std::move(from);
  }

  inline Entrance& operator=(const Entrance& from) {
    CopyFrom(from);
    return *this;
  }
  inline Entrance& operator=(Entrance&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Entrance& default_instance() {
    return *internal_default_instance();
  }
  static inline const Entrance* internal_default_instance() {
    return reinterpret_cast<const Entrance*>(
               &_Entrance_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Entrance& a, Entrance& b) {
    a.Swap(&b);
  }
  inline void Swap(Entrance* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Entrance* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Entrance* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Entrance>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Entrance& from);
  void MergeFrom(const Entrance& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Entrance* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.Entrance";
  }
  protected:
  explicit Entrance(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOrponFieldNumber = 1,
    kEntranceNumberFieldNumber = 2,
    kStartRoomNumberFieldNumber = 3,
    kRoomsCountPerFloorFieldNumber = 4,
    kFloorsCountFieldNumber = 5,
  };
  // int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
  void clear_orpon() ;
  ::int64_t orpon() const;
  void set_orpon(::int64_t value);

  private:
  ::int64_t _internal_orpon() const;
  void _internal_set_orpon(::int64_t value);

  public:
  // int32 entrance_number = 2 [(.google.api.field_behavior) = REQUIRED];
  void clear_entrance_number() ;
  ::int32_t entrance_number() const;
  void set_entrance_number(::int32_t value);

  private:
  ::int32_t _internal_entrance_number() const;
  void _internal_set_entrance_number(::int32_t value);

  public:
  // int32 start_room_number = 3 [(.google.api.field_behavior) = REQUIRED];
  void clear_start_room_number() ;
  ::int32_t start_room_number() const;
  void set_start_room_number(::int32_t value);

  private:
  ::int32_t _internal_start_room_number() const;
  void _internal_set_start_room_number(::int32_t value);

  public:
  // int32 rooms_count_per_floor = 4 [(.google.api.field_behavior) = REQUIRED];
  void clear_rooms_count_per_floor() ;
  ::int32_t rooms_count_per_floor() const;
  void set_rooms_count_per_floor(::int32_t value);

  private:
  ::int32_t _internal_rooms_count_per_floor() const;
  void _internal_set_rooms_count_per_floor(::int32_t value);

  public:
  // int32 floors_count = 5 [(.google.api.field_behavior) = REQUIRED];
  void clear_floors_count() ;
  ::int32_t floors_count() const;
  void set_floors_count(::int32_t value);

  private:
  ::int32_t _internal_floors_count() const;
  void _internal_set_floors_count(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.Entrance)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::int64_t orpon_;
    ::int32_t entrance_number_;
    ::int32_t start_room_number_;
    ::int32_t rooms_count_per_floor_;
    ::int32_t floors_count_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class EntranceFilter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.EntranceFilter) */ {
 public:
  inline EntranceFilter() : EntranceFilter(nullptr) {}
  ~EntranceFilter() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EntranceFilter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  EntranceFilter(const EntranceFilter& from);
  EntranceFilter(EntranceFilter&& from) noexcept
    : EntranceFilter() {
    *this = ::std::move(from);
  }

  inline EntranceFilter& operator=(const EntranceFilter& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntranceFilter& operator=(EntranceFilter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const EntranceFilter& default_instance() {
    return *internal_default_instance();
  }
  static inline const EntranceFilter* internal_default_instance() {
    return reinterpret_cast<const EntranceFilter*>(
               &_EntranceFilter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(EntranceFilter& a, EntranceFilter& b) {
    a.Swap(&b);
  }
  inline void Swap(EntranceFilter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(EntranceFilter* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  EntranceFilter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntranceFilter>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const EntranceFilter& from);
  void MergeFrom(const EntranceFilter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EntranceFilter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.EntranceFilter";
  }
  protected:
  explicit EntranceFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  using CompanyRelationType = EntranceFilter_CompanyRelationType;
  static constexpr CompanyRelationType COMPANY_RELATION_TYPE_UNKNOWN = EntranceFilter_CompanyRelationType_COMPANY_RELATION_TYPE_UNKNOWN;
  static constexpr CompanyRelationType DEFAULT = EntranceFilter_CompanyRelationType_DEFAULT;
  static constexpr CompanyRelationType MANAGEMENT = EntranceFilter_CompanyRelationType_MANAGEMENT;
  static constexpr CompanyRelationType DEVICE_SERVICE = EntranceFilter_CompanyRelationType_DEVICE_SERVICE;
  static inline bool CompanyRelationType_IsValid(int value) {
    return EntranceFilter_CompanyRelationType_IsValid(value);
  }
  static constexpr CompanyRelationType CompanyRelationType_MIN = EntranceFilter_CompanyRelationType_CompanyRelationType_MIN;
  static constexpr CompanyRelationType CompanyRelationType_MAX = EntranceFilter_CompanyRelationType_CompanyRelationType_MAX;
  static constexpr int CompanyRelationType_ARRAYSIZE = EntranceFilter_CompanyRelationType_CompanyRelationType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& CompanyRelationType_Name(T value) {
    return EntranceFilter_CompanyRelationType_Name(value);
  }
  static inline bool CompanyRelationType_Parse(absl::string_view name, CompanyRelationType* value) {
    return EntranceFilter_CompanyRelationType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kFlatgrammIdsFieldNumber = 1,
    kOrponsFieldNumber = 2,
    kCompanyIdsFieldNumber = 3,
    kCompanyRelationTypeFieldNumber = 4,
  };
  // repeated int32 flatgramm_ids = 1;
  int flatgramm_ids_size() const;
  private:
  int _internal_flatgramm_ids_size() const;

  public:
  void clear_flatgramm_ids() ;
  ::int32_t flatgramm_ids(int index) const;
  void set_flatgramm_ids(int index, ::int32_t value);
  void add_flatgramm_ids(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& flatgramm_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* mutable_flatgramm_ids();

  private:
  ::int32_t _internal_flatgramm_ids(int index) const;
  void _internal_add_flatgramm_ids(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& _internal_flatgramm_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* _internal_mutable_flatgramm_ids();

  public:
  // repeated int64 orpons = 2;
  int orpons_size() const;
  private:
  int _internal_orpons_size() const;

  public:
  void clear_orpons() ;
  ::int64_t orpons(int index) const;
  void set_orpons(int index, ::int64_t value);
  void add_orpons(::int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>& orpons() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>* mutable_orpons();

  private:
  ::int64_t _internal_orpons(int index) const;
  void _internal_add_orpons(::int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>& _internal_orpons() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>* _internal_mutable_orpons();

  public:
  // repeated int32 company_ids = 3;
  int company_ids_size() const;
  private:
  int _internal_company_ids_size() const;

  public:
  void clear_company_ids() ;
  ::int32_t company_ids(int index) const;
  void set_company_ids(int index, ::int32_t value);
  void add_company_ids(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& company_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* mutable_company_ids();

  private:
  ::int32_t _internal_company_ids(int index) const;
  void _internal_add_company_ids(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& _internal_company_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* _internal_mutable_company_ids();

  public:
  // .keyapis.access_control.v1.EntranceFilter.CompanyRelationType company_relation_type = 4;
  void clear_company_relation_type() ;
  ::keyapis::access_control::v1::EntranceFilter_CompanyRelationType company_relation_type() const;
  void set_company_relation_type(::keyapis::access_control::v1::EntranceFilter_CompanyRelationType value);

  private:
  ::keyapis::access_control::v1::EntranceFilter_CompanyRelationType _internal_company_relation_type() const;
  void _internal_set_company_relation_type(::keyapis::access_control::v1::EntranceFilter_CompanyRelationType value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.EntranceFilter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t> flatgramm_ids_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _flatgramm_ids_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t> orpons_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _orpons_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t> company_ids_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _company_ids_cached_byte_size_;
    int company_relation_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class EntrancePaging final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.EntrancePaging) */ {
 public:
  inline EntrancePaging() : EntrancePaging(nullptr) {}
  ~EntrancePaging() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EntrancePaging(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  EntrancePaging(const EntrancePaging& from);
  EntrancePaging(EntrancePaging&& from) noexcept
    : EntrancePaging() {
    *this = ::std::move(from);
  }

  inline EntrancePaging& operator=(const EntrancePaging& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntrancePaging& operator=(EntrancePaging&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const EntrancePaging& default_instance() {
    return *internal_default_instance();
  }
  static inline const EntrancePaging* internal_default_instance() {
    return reinterpret_cast<const EntrancePaging*>(
               &_EntrancePaging_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(EntrancePaging& a, EntrancePaging& b) {
    a.Swap(&b);
  }
  inline void Swap(EntrancePaging* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(EntrancePaging* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  EntrancePaging* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntrancePaging>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const EntrancePaging& from);
  void MergeFrom(const EntrancePaging& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EntrancePaging* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.EntrancePaging";
  }
  protected:
  explicit EntrancePaging(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  using OrderByType = EntrancePaging_OrderByType;
  static constexpr OrderByType ORDER_BY_TYPE_UNKNOWN = EntrancePaging_OrderByType_ORDER_BY_TYPE_UNKNOWN;
  static constexpr OrderByType ORPON_THEN_ENTRANCE_NUMBER = EntrancePaging_OrderByType_ORPON_THEN_ENTRANCE_NUMBER;
  static inline bool OrderByType_IsValid(int value) {
    return EntrancePaging_OrderByType_IsValid(value);
  }
  static constexpr OrderByType OrderByType_MIN = EntrancePaging_OrderByType_OrderByType_MIN;
  static constexpr OrderByType OrderByType_MAX = EntrancePaging_OrderByType_OrderByType_MAX;
  static constexpr int OrderByType_ARRAYSIZE = EntrancePaging_OrderByType_OrderByType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& OrderByType_Name(T value) {
    return EntrancePaging_OrderByType_Name(value);
  }
  static inline bool OrderByType_Parse(absl::string_view name, OrderByType* value) {
    return EntrancePaging_OrderByType_Parse(name, value);
  }

  using DirectionType = EntrancePaging_DirectionType;
  static constexpr DirectionType DIRECTION_TYPE_UNKNOWN = EntrancePaging_DirectionType_DIRECTION_TYPE_UNKNOWN;
  static constexpr DirectionType DESC = EntrancePaging_DirectionType_DESC;
  static constexpr DirectionType ASC = EntrancePaging_DirectionType_ASC;
  static inline bool DirectionType_IsValid(int value) {
    return EntrancePaging_DirectionType_IsValid(value);
  }
  static constexpr DirectionType DirectionType_MIN = EntrancePaging_DirectionType_DirectionType_MIN;
  static constexpr DirectionType DirectionType_MAX = EntrancePaging_DirectionType_DirectionType_MAX;
  static constexpr int DirectionType_ARRAYSIZE = EntrancePaging_DirectionType_DirectionType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& DirectionType_Name(T value) {
    return EntrancePaging_DirectionType_Name(value);
  }
  static inline bool DirectionType_Parse(absl::string_view name, DirectionType* value) {
    return EntrancePaging_DirectionType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kOrderByTypeFieldNumber = 1,
    kDirectionTypeFieldNumber = 2,
    kLimitFieldNumber = 3,
    kOffsetFieldNumber = 4,
  };
  // .keyapis.access_control.v1.EntrancePaging.OrderByType order_by_type = 1;
  void clear_order_by_type() ;
  ::keyapis::access_control::v1::EntrancePaging_OrderByType order_by_type() const;
  void set_order_by_type(::keyapis::access_control::v1::EntrancePaging_OrderByType value);

  private:
  ::keyapis::access_control::v1::EntrancePaging_OrderByType _internal_order_by_type() const;
  void _internal_set_order_by_type(::keyapis::access_control::v1::EntrancePaging_OrderByType value);

  public:
  // .keyapis.access_control.v1.EntrancePaging.DirectionType direction_type = 2;
  void clear_direction_type() ;
  ::keyapis::access_control::v1::EntrancePaging_DirectionType direction_type() const;
  void set_direction_type(::keyapis::access_control::v1::EntrancePaging_DirectionType value);

  private:
  ::keyapis::access_control::v1::EntrancePaging_DirectionType _internal_direction_type() const;
  void _internal_set_direction_type(::keyapis::access_control::v1::EntrancePaging_DirectionType value);

  public:
  // int32 limit = 3;
  void clear_limit() ;
  ::int32_t limit() const;
  void set_limit(::int32_t value);

  private:
  ::int32_t _internal_limit() const;
  void _internal_set_limit(::int32_t value);

  public:
  // int32 offset = 4;
  void clear_offset() ;
  ::int32_t offset() const;
  void set_offset(::int32_t value);

  private:
  ::int32_t _internal_offset() const;
  void _internal_set_offset(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.EntrancePaging)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int order_by_type_;
    int direction_type_;
    ::int32_t limit_;
    ::int32_t offset_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetEntranceListRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.GetEntranceListRequest) */ {
 public:
  inline GetEntranceListRequest() : GetEntranceListRequest(nullptr) {}
  ~GetEntranceListRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetEntranceListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetEntranceListRequest(const GetEntranceListRequest& from);
  GetEntranceListRequest(GetEntranceListRequest&& from) noexcept
    : GetEntranceListRequest() {
    *this = ::std::move(from);
  }

  inline GetEntranceListRequest& operator=(const GetEntranceListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetEntranceListRequest& operator=(GetEntranceListRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetEntranceListRequest& default_instance() {
    return *internal_default_instance();
  }
  enum PaginationCase {
    kPaging = 2,
    PAGINATION_NOT_SET = 0,
  };

  static inline const GetEntranceListRequest* internal_default_instance() {
    return reinterpret_cast<const GetEntranceListRequest*>(
               &_GetEntranceListRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(GetEntranceListRequest& a, GetEntranceListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetEntranceListRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetEntranceListRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetEntranceListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetEntranceListRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetEntranceListRequest& from);
  void MergeFrom(const GetEntranceListRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetEntranceListRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.GetEntranceListRequest";
  }
  protected:
  explicit GetEntranceListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFilterFieldNumber = 1,
    kPagingFieldNumber = 2,
  };
  // .keyapis.access_control.v1.EntranceFilter filter = 1;
  bool has_filter() const;
  void clear_filter() ;
  const ::keyapis::access_control::v1::EntranceFilter& filter() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::EntranceFilter* release_filter();
  ::keyapis::access_control::v1::EntranceFilter* mutable_filter();
  void set_allocated_filter(::keyapis::access_control::v1::EntranceFilter* filter);
  private:
  const ::keyapis::access_control::v1::EntranceFilter& _internal_filter() const;
  ::keyapis::access_control::v1::EntranceFilter* _internal_mutable_filter();
  public:
  void unsafe_arena_set_allocated_filter(
      ::keyapis::access_control::v1::EntranceFilter* filter);
  ::keyapis::access_control::v1::EntranceFilter* unsafe_arena_release_filter();
  // .keyapis.access_control.v1.EntrancePaging paging = 2;
  bool has_paging() const;
  private:
  bool _internal_has_paging() const;

  public:
  void clear_paging() ;
  const ::keyapis::access_control::v1::EntrancePaging& paging() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::EntrancePaging* release_paging();
  ::keyapis::access_control::v1::EntrancePaging* mutable_paging();
  void set_allocated_paging(::keyapis::access_control::v1::EntrancePaging* paging);
  private:
  const ::keyapis::access_control::v1::EntrancePaging& _internal_paging() const;
  ::keyapis::access_control::v1::EntrancePaging* _internal_mutable_paging();
  public:
  void unsafe_arena_set_allocated_paging(
      ::keyapis::access_control::v1::EntrancePaging* paging);
  ::keyapis::access_control::v1::EntrancePaging* unsafe_arena_release_paging();
  void clear_pagination();
  PaginationCase pagination_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.GetEntranceListRequest)
 private:
  class _Internal;
  void set_has_paging();

  inline bool has_pagination() const;
  inline void clear_has_pagination();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::keyapis::access_control::v1::EntranceFilter* filter_;
    union PaginationUnion {
      constexpr PaginationUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::EntrancePaging* paging_;
    } pagination_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetEntranceListResponse_Error final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.GetEntranceListResponse.Error) */ {
 public:
  inline GetEntranceListResponse_Error() : GetEntranceListResponse_Error(nullptr) {}
  ~GetEntranceListResponse_Error() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetEntranceListResponse_Error(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetEntranceListResponse_Error(const GetEntranceListResponse_Error& from);
  GetEntranceListResponse_Error(GetEntranceListResponse_Error&& from) noexcept
    : GetEntranceListResponse_Error() {
    *this = ::std::move(from);
  }

  inline GetEntranceListResponse_Error& operator=(const GetEntranceListResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetEntranceListResponse_Error& operator=(GetEntranceListResponse_Error&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetEntranceListResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

  static inline const GetEntranceListResponse_Error* internal_default_instance() {
    return reinterpret_cast<const GetEntranceListResponse_Error*>(
               &_GetEntranceListResponse_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(GetEntranceListResponse_Error& a, GetEntranceListResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(GetEntranceListResponse_Error* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetEntranceListResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetEntranceListResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetEntranceListResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetEntranceListResponse_Error& from);
  void MergeFrom(const GetEntranceListResponse_Error& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetEntranceListResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.GetEntranceListResponse.Error";
  }
  protected:
  explicit GetEntranceListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValidationFieldNumber = 1,
  };
  // .keyapis.access_control.v1.ValidationError validation = 1;
  bool has_validation() const;
  private:
  bool _internal_has_validation() const;

  public:
  void clear_validation() ;
  const ::keyapis::access_control::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::ValidationError* release_validation();
  ::keyapis::access_control::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation);
  private:
  const ::keyapis::access_control::v1::ValidationError& _internal_validation() const;
  ::keyapis::access_control::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::keyapis::access_control::v1::ValidationError* validation);
  ::keyapis::access_control::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.GetEntranceListResponse.Error)
 private:
  class _Internal;
  void set_has_validation();

  inline bool has_reason() const;
  inline void clear_has_reason();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetEntranceListResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.GetEntranceListResponse) */ {
 public:
  inline GetEntranceListResponse() : GetEntranceListResponse(nullptr) {}
  ~GetEntranceListResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetEntranceListResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetEntranceListResponse(const GetEntranceListResponse& from);
  GetEntranceListResponse(GetEntranceListResponse&& from) noexcept
    : GetEntranceListResponse() {
    *this = ::std::move(from);
  }

  inline GetEntranceListResponse& operator=(const GetEntranceListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetEntranceListResponse& operator=(GetEntranceListResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetEntranceListResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    kError = 2,
    TYPE_NOT_SET = 0,
  };

  static inline const GetEntranceListResponse* internal_default_instance() {
    return reinterpret_cast<const GetEntranceListResponse*>(
               &_GetEntranceListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(GetEntranceListResponse& a, GetEntranceListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetEntranceListResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetEntranceListResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetEntranceListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetEntranceListResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetEntranceListResponse& from);
  void MergeFrom(const GetEntranceListResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetEntranceListResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.GetEntranceListResponse";
  }
  protected:
  explicit GetEntranceListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef GetEntranceListResponse_Error Error;

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
    kErrorFieldNumber = 2,
  };
  // .keyapis.access_control.v1.Entrance data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::keyapis::access_control::v1::Entrance& data() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::Entrance* release_data();
  ::keyapis::access_control::v1::Entrance* mutable_data();
  void set_allocated_data(::keyapis::access_control::v1::Entrance* data);
  private:
  const ::keyapis::access_control::v1::Entrance& _internal_data() const;
  ::keyapis::access_control::v1::Entrance* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::keyapis::access_control::v1::Entrance* data);
  ::keyapis::access_control::v1::Entrance* unsafe_arena_release_data();
  // .keyapis.access_control.v1.GetEntranceListResponse.Error error = 2;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::keyapis::access_control::v1::GetEntranceListResponse_Error& error() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::GetEntranceListResponse_Error* release_error();
  ::keyapis::access_control::v1::GetEntranceListResponse_Error* mutable_error();
  void set_allocated_error(::keyapis::access_control::v1::GetEntranceListResponse_Error* error);
  private:
  const ::keyapis::access_control::v1::GetEntranceListResponse_Error& _internal_error() const;
  ::keyapis::access_control::v1::GetEntranceListResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::keyapis::access_control::v1::GetEntranceListResponse_Error* error);
  ::keyapis::access_control::v1::GetEntranceListResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.GetEntranceListResponse)
 private:
  class _Internal;
  void set_has_data();
  void set_has_error();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::Entrance* data_;
      ::keyapis::access_control::v1::GetEntranceListResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PutEntranceDeviceAttachRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PutEntranceDeviceAttachRequest) */ {
 public:
  inline PutEntranceDeviceAttachRequest() : PutEntranceDeviceAttachRequest(nullptr) {}
  ~PutEntranceDeviceAttachRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PutEntranceDeviceAttachRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PutEntranceDeviceAttachRequest(const PutEntranceDeviceAttachRequest& from);
  PutEntranceDeviceAttachRequest(PutEntranceDeviceAttachRequest&& from) noexcept
    : PutEntranceDeviceAttachRequest() {
    *this = ::std::move(from);
  }

  inline PutEntranceDeviceAttachRequest& operator=(const PutEntranceDeviceAttachRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline PutEntranceDeviceAttachRequest& operator=(PutEntranceDeviceAttachRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PutEntranceDeviceAttachRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const PutEntranceDeviceAttachRequest* internal_default_instance() {
    return reinterpret_cast<const PutEntranceDeviceAttachRequest*>(
               &_PutEntranceDeviceAttachRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(PutEntranceDeviceAttachRequest& a, PutEntranceDeviceAttachRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(PutEntranceDeviceAttachRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PutEntranceDeviceAttachRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PutEntranceDeviceAttachRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PutEntranceDeviceAttachRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PutEntranceDeviceAttachRequest& from);
  void MergeFrom(const PutEntranceDeviceAttachRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PutEntranceDeviceAttachRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PutEntranceDeviceAttachRequest";
  }
  protected:
  explicit PutEntranceDeviceAttachRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEntranceDeviceFieldNumber = 1,
  };
  // .keyapis.access_control.v1.EntranceDevice entrance_device = 1 [(.google.api.field_behavior) = REQUIRED];
  bool has_entrance_device() const;
  void clear_entrance_device() ;
  const ::keyapis::access_control::v1::EntranceDevice& entrance_device() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::EntranceDevice* release_entrance_device();
  ::keyapis::access_control::v1::EntranceDevice* mutable_entrance_device();
  void set_allocated_entrance_device(::keyapis::access_control::v1::EntranceDevice* entrance_device);
  private:
  const ::keyapis::access_control::v1::EntranceDevice& _internal_entrance_device() const;
  ::keyapis::access_control::v1::EntranceDevice* _internal_mutable_entrance_device();
  public:
  void unsafe_arena_set_allocated_entrance_device(
      ::keyapis::access_control::v1::EntranceDevice* entrance_device);
  ::keyapis::access_control::v1::EntranceDevice* unsafe_arena_release_entrance_device();
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PutEntranceDeviceAttachRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::keyapis::access_control::v1::EntranceDevice* entrance_device_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PutEntranceDeviceAttachResponse_Error final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error) */ {
 public:
  inline PutEntranceDeviceAttachResponse_Error() : PutEntranceDeviceAttachResponse_Error(nullptr) {}
  ~PutEntranceDeviceAttachResponse_Error() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PutEntranceDeviceAttachResponse_Error(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PutEntranceDeviceAttachResponse_Error(const PutEntranceDeviceAttachResponse_Error& from);
  PutEntranceDeviceAttachResponse_Error(PutEntranceDeviceAttachResponse_Error&& from) noexcept
    : PutEntranceDeviceAttachResponse_Error() {
    *this = ::std::move(from);
  }

  inline PutEntranceDeviceAttachResponse_Error& operator=(const PutEntranceDeviceAttachResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline PutEntranceDeviceAttachResponse_Error& operator=(PutEntranceDeviceAttachResponse_Error&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PutEntranceDeviceAttachResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

  static inline const PutEntranceDeviceAttachResponse_Error* internal_default_instance() {
    return reinterpret_cast<const PutEntranceDeviceAttachResponse_Error*>(
               &_PutEntranceDeviceAttachResponse_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(PutEntranceDeviceAttachResponse_Error& a, PutEntranceDeviceAttachResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(PutEntranceDeviceAttachResponse_Error* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PutEntranceDeviceAttachResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PutEntranceDeviceAttachResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PutEntranceDeviceAttachResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PutEntranceDeviceAttachResponse_Error& from);
  void MergeFrom(const PutEntranceDeviceAttachResponse_Error& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PutEntranceDeviceAttachResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error";
  }
  protected:
  explicit PutEntranceDeviceAttachResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValidationFieldNumber = 1,
  };
  // .keyapis.access_control.v1.ValidationError validation = 1;
  bool has_validation() const;
  private:
  bool _internal_has_validation() const;

  public:
  void clear_validation() ;
  const ::keyapis::access_control::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::ValidationError* release_validation();
  ::keyapis::access_control::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation);
  private:
  const ::keyapis::access_control::v1::ValidationError& _internal_validation() const;
  ::keyapis::access_control::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::keyapis::access_control::v1::ValidationError* validation);
  ::keyapis::access_control::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error)
 private:
  class _Internal;
  void set_has_validation();

  inline bool has_reason() const;
  inline void clear_has_reason();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PutEntranceDeviceAttachResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PutEntranceDeviceAttachResponse) */ {
 public:
  inline PutEntranceDeviceAttachResponse() : PutEntranceDeviceAttachResponse(nullptr) {}
  ~PutEntranceDeviceAttachResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PutEntranceDeviceAttachResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PutEntranceDeviceAttachResponse(const PutEntranceDeviceAttachResponse& from);
  PutEntranceDeviceAttachResponse(PutEntranceDeviceAttachResponse&& from) noexcept
    : PutEntranceDeviceAttachResponse() {
    *this = ::std::move(from);
  }

  inline PutEntranceDeviceAttachResponse& operator=(const PutEntranceDeviceAttachResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PutEntranceDeviceAttachResponse& operator=(PutEntranceDeviceAttachResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PutEntranceDeviceAttachResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kError = 1,
    TYPE_NOT_SET = 0,
  };

  static inline const PutEntranceDeviceAttachResponse* internal_default_instance() {
    return reinterpret_cast<const PutEntranceDeviceAttachResponse*>(
               &_PutEntranceDeviceAttachResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(PutEntranceDeviceAttachResponse& a, PutEntranceDeviceAttachResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PutEntranceDeviceAttachResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PutEntranceDeviceAttachResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PutEntranceDeviceAttachResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PutEntranceDeviceAttachResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PutEntranceDeviceAttachResponse& from);
  void MergeFrom(const PutEntranceDeviceAttachResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PutEntranceDeviceAttachResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PutEntranceDeviceAttachResponse";
  }
  protected:
  explicit PutEntranceDeviceAttachResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef PutEntranceDeviceAttachResponse_Error Error;

  // accessors -------------------------------------------------------

  enum : int {
    kErrorFieldNumber = 1,
  };
  // .keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error error = 1;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error& error() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* release_error();
  ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* mutable_error();
  void set_allocated_error(::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* error);
  private:
  const ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error& _internal_error() const;
  ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* error);
  ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PutEntranceDeviceAttachResponse)
 private:
  class _Internal;
  void set_has_error();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PutEntranceDeviceDetachRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PutEntranceDeviceDetachRequest) */ {
 public:
  inline PutEntranceDeviceDetachRequest() : PutEntranceDeviceDetachRequest(nullptr) {}
  ~PutEntranceDeviceDetachRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PutEntranceDeviceDetachRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PutEntranceDeviceDetachRequest(const PutEntranceDeviceDetachRequest& from);
  PutEntranceDeviceDetachRequest(PutEntranceDeviceDetachRequest&& from) noexcept
    : PutEntranceDeviceDetachRequest() {
    *this = ::std::move(from);
  }

  inline PutEntranceDeviceDetachRequest& operator=(const PutEntranceDeviceDetachRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline PutEntranceDeviceDetachRequest& operator=(PutEntranceDeviceDetachRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PutEntranceDeviceDetachRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const PutEntranceDeviceDetachRequest* internal_default_instance() {
    return reinterpret_cast<const PutEntranceDeviceDetachRequest*>(
               &_PutEntranceDeviceDetachRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(PutEntranceDeviceDetachRequest& a, PutEntranceDeviceDetachRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(PutEntranceDeviceDetachRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PutEntranceDeviceDetachRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PutEntranceDeviceDetachRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PutEntranceDeviceDetachRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PutEntranceDeviceDetachRequest& from);
  void MergeFrom(const PutEntranceDeviceDetachRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PutEntranceDeviceDetachRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PutEntranceDeviceDetachRequest";
  }
  protected:
  explicit PutEntranceDeviceDetachRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEntranceDeviceFieldNumber = 1,
  };
  // .keyapis.access_control.v1.EntranceDevice entrance_device = 1 [(.google.api.field_behavior) = REQUIRED];
  bool has_entrance_device() const;
  void clear_entrance_device() ;
  const ::keyapis::access_control::v1::EntranceDevice& entrance_device() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::EntranceDevice* release_entrance_device();
  ::keyapis::access_control::v1::EntranceDevice* mutable_entrance_device();
  void set_allocated_entrance_device(::keyapis::access_control::v1::EntranceDevice* entrance_device);
  private:
  const ::keyapis::access_control::v1::EntranceDevice& _internal_entrance_device() const;
  ::keyapis::access_control::v1::EntranceDevice* _internal_mutable_entrance_device();
  public:
  void unsafe_arena_set_allocated_entrance_device(
      ::keyapis::access_control::v1::EntranceDevice* entrance_device);
  ::keyapis::access_control::v1::EntranceDevice* unsafe_arena_release_entrance_device();
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PutEntranceDeviceDetachRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::keyapis::access_control::v1::EntranceDevice* entrance_device_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PutEntranceDeviceDetachResponse_Error final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error) */ {
 public:
  inline PutEntranceDeviceDetachResponse_Error() : PutEntranceDeviceDetachResponse_Error(nullptr) {}
  ~PutEntranceDeviceDetachResponse_Error() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PutEntranceDeviceDetachResponse_Error(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PutEntranceDeviceDetachResponse_Error(const PutEntranceDeviceDetachResponse_Error& from);
  PutEntranceDeviceDetachResponse_Error(PutEntranceDeviceDetachResponse_Error&& from) noexcept
    : PutEntranceDeviceDetachResponse_Error() {
    *this = ::std::move(from);
  }

  inline PutEntranceDeviceDetachResponse_Error& operator=(const PutEntranceDeviceDetachResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline PutEntranceDeviceDetachResponse_Error& operator=(PutEntranceDeviceDetachResponse_Error&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PutEntranceDeviceDetachResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

  static inline const PutEntranceDeviceDetachResponse_Error* internal_default_instance() {
    return reinterpret_cast<const PutEntranceDeviceDetachResponse_Error*>(
               &_PutEntranceDeviceDetachResponse_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(PutEntranceDeviceDetachResponse_Error& a, PutEntranceDeviceDetachResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(PutEntranceDeviceDetachResponse_Error* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PutEntranceDeviceDetachResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PutEntranceDeviceDetachResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PutEntranceDeviceDetachResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PutEntranceDeviceDetachResponse_Error& from);
  void MergeFrom(const PutEntranceDeviceDetachResponse_Error& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PutEntranceDeviceDetachResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error";
  }
  protected:
  explicit PutEntranceDeviceDetachResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValidationFieldNumber = 1,
  };
  // .keyapis.access_control.v1.ValidationError validation = 1;
  bool has_validation() const;
  private:
  bool _internal_has_validation() const;

  public:
  void clear_validation() ;
  const ::keyapis::access_control::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::ValidationError* release_validation();
  ::keyapis::access_control::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation);
  private:
  const ::keyapis::access_control::v1::ValidationError& _internal_validation() const;
  ::keyapis::access_control::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::keyapis::access_control::v1::ValidationError* validation);
  ::keyapis::access_control::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error)
 private:
  class _Internal;
  void set_has_validation();

  inline bool has_reason() const;
  inline void clear_has_reason();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PutEntranceDeviceDetachResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PutEntranceDeviceDetachResponse) */ {
 public:
  inline PutEntranceDeviceDetachResponse() : PutEntranceDeviceDetachResponse(nullptr) {}
  ~PutEntranceDeviceDetachResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PutEntranceDeviceDetachResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PutEntranceDeviceDetachResponse(const PutEntranceDeviceDetachResponse& from);
  PutEntranceDeviceDetachResponse(PutEntranceDeviceDetachResponse&& from) noexcept
    : PutEntranceDeviceDetachResponse() {
    *this = ::std::move(from);
  }

  inline PutEntranceDeviceDetachResponse& operator=(const PutEntranceDeviceDetachResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PutEntranceDeviceDetachResponse& operator=(PutEntranceDeviceDetachResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PutEntranceDeviceDetachResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kError = 1,
    TYPE_NOT_SET = 0,
  };

  static inline const PutEntranceDeviceDetachResponse* internal_default_instance() {
    return reinterpret_cast<const PutEntranceDeviceDetachResponse*>(
               &_PutEntranceDeviceDetachResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(PutEntranceDeviceDetachResponse& a, PutEntranceDeviceDetachResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PutEntranceDeviceDetachResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PutEntranceDeviceDetachResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PutEntranceDeviceDetachResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PutEntranceDeviceDetachResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PutEntranceDeviceDetachResponse& from);
  void MergeFrom(const PutEntranceDeviceDetachResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PutEntranceDeviceDetachResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PutEntranceDeviceDetachResponse";
  }
  protected:
  explicit PutEntranceDeviceDetachResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef PutEntranceDeviceDetachResponse_Error Error;

  // accessors -------------------------------------------------------

  enum : int {
    kErrorFieldNumber = 1,
  };
  // .keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error error = 1;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error& error() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* release_error();
  ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* mutable_error();
  void set_allocated_error(::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* error);
  private:
  const ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error& _internal_error() const;
  ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* error);
  ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PutEntranceDeviceDetachResponse)
 private:
  class _Internal;
  void set_has_error();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PostEntranceRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PostEntranceRequest) */ {
 public:
  inline PostEntranceRequest() : PostEntranceRequest(nullptr) {}
  ~PostEntranceRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PostEntranceRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PostEntranceRequest(const PostEntranceRequest& from);
  PostEntranceRequest(PostEntranceRequest&& from) noexcept
    : PostEntranceRequest() {
    *this = ::std::move(from);
  }

  inline PostEntranceRequest& operator=(const PostEntranceRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline PostEntranceRequest& operator=(PostEntranceRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PostEntranceRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const PostEntranceRequest* internal_default_instance() {
    return reinterpret_cast<const PostEntranceRequest*>(
               &_PostEntranceRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(PostEntranceRequest& a, PostEntranceRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(PostEntranceRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PostEntranceRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PostEntranceRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PostEntranceRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PostEntranceRequest& from);
  void MergeFrom(const PostEntranceRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PostEntranceRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PostEntranceRequest";
  }
  protected:
  explicit PostEntranceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // .keyapis.access_control.v1.Entrance data = 1 [(.google.api.field_behavior) = REQUIRED];
  bool has_data() const;
  void clear_data() ;
  const ::keyapis::access_control::v1::Entrance& data() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::Entrance* release_data();
  ::keyapis::access_control::v1::Entrance* mutable_data();
  void set_allocated_data(::keyapis::access_control::v1::Entrance* data);
  private:
  const ::keyapis::access_control::v1::Entrance& _internal_data() const;
  ::keyapis::access_control::v1::Entrance* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::keyapis::access_control::v1::Entrance* data);
  ::keyapis::access_control::v1::Entrance* unsafe_arena_release_data();
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PostEntranceRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::keyapis::access_control::v1::Entrance* data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PostEntranceResponse_Error final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PostEntranceResponse.Error) */ {
 public:
  inline PostEntranceResponse_Error() : PostEntranceResponse_Error(nullptr) {}
  ~PostEntranceResponse_Error() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PostEntranceResponse_Error(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PostEntranceResponse_Error(const PostEntranceResponse_Error& from);
  PostEntranceResponse_Error(PostEntranceResponse_Error&& from) noexcept
    : PostEntranceResponse_Error() {
    *this = ::std::move(from);
  }

  inline PostEntranceResponse_Error& operator=(const PostEntranceResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline PostEntranceResponse_Error& operator=(PostEntranceResponse_Error&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PostEntranceResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

  static inline const PostEntranceResponse_Error* internal_default_instance() {
    return reinterpret_cast<const PostEntranceResponse_Error*>(
               &_PostEntranceResponse_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(PostEntranceResponse_Error& a, PostEntranceResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(PostEntranceResponse_Error* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PostEntranceResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PostEntranceResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PostEntranceResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PostEntranceResponse_Error& from);
  void MergeFrom(const PostEntranceResponse_Error& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PostEntranceResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PostEntranceResponse.Error";
  }
  protected:
  explicit PostEntranceResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValidationFieldNumber = 1,
  };
  // .keyapis.access_control.v1.ValidationError validation = 1;
  bool has_validation() const;
  private:
  bool _internal_has_validation() const;

  public:
  void clear_validation() ;
  const ::keyapis::access_control::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::ValidationError* release_validation();
  ::keyapis::access_control::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation);
  private:
  const ::keyapis::access_control::v1::ValidationError& _internal_validation() const;
  ::keyapis::access_control::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::keyapis::access_control::v1::ValidationError* validation);
  ::keyapis::access_control::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PostEntranceResponse.Error)
 private:
  class _Internal;
  void set_has_validation();

  inline bool has_reason() const;
  inline void clear_has_reason();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class PostEntranceResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.PostEntranceResponse) */ {
 public:
  inline PostEntranceResponse() : PostEntranceResponse(nullptr) {}
  ~PostEntranceResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PostEntranceResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PostEntranceResponse(const PostEntranceResponse& from);
  PostEntranceResponse(PostEntranceResponse&& from) noexcept
    : PostEntranceResponse() {
    *this = ::std::move(from);
  }

  inline PostEntranceResponse& operator=(const PostEntranceResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PostEntranceResponse& operator=(PostEntranceResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PostEntranceResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    kError = 2,
    TYPE_NOT_SET = 0,
  };

  static inline const PostEntranceResponse* internal_default_instance() {
    return reinterpret_cast<const PostEntranceResponse*>(
               &_PostEntranceResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(PostEntranceResponse& a, PostEntranceResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PostEntranceResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PostEntranceResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PostEntranceResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PostEntranceResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PostEntranceResponse& from);
  void MergeFrom(const PostEntranceResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PostEntranceResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.PostEntranceResponse";
  }
  protected:
  explicit PostEntranceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef PostEntranceResponse_Error Error;

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
    kErrorFieldNumber = 2,
  };
  // .keyapis.access_control.v1.Entrance data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::keyapis::access_control::v1::Entrance& data() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::Entrance* release_data();
  ::keyapis::access_control::v1::Entrance* mutable_data();
  void set_allocated_data(::keyapis::access_control::v1::Entrance* data);
  private:
  const ::keyapis::access_control::v1::Entrance& _internal_data() const;
  ::keyapis::access_control::v1::Entrance* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::keyapis::access_control::v1::Entrance* data);
  ::keyapis::access_control::v1::Entrance* unsafe_arena_release_data();
  // .keyapis.access_control.v1.PostEntranceResponse.Error error = 2;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::keyapis::access_control::v1::PostEntranceResponse_Error& error() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::PostEntranceResponse_Error* release_error();
  ::keyapis::access_control::v1::PostEntranceResponse_Error* mutable_error();
  void set_allocated_error(::keyapis::access_control::v1::PostEntranceResponse_Error* error);
  private:
  const ::keyapis::access_control::v1::PostEntranceResponse_Error& _internal_error() const;
  ::keyapis::access_control::v1::PostEntranceResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::keyapis::access_control::v1::PostEntranceResponse_Error* error);
  ::keyapis::access_control::v1::PostEntranceResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.PostEntranceResponse)
 private:
  class _Internal;
  void set_has_data();
  void set_has_error();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::Entrance* data_;
      ::keyapis::access_control::v1::PostEntranceResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class DeleteEntranceRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.DeleteEntranceRequest) */ {
 public:
  inline DeleteEntranceRequest() : DeleteEntranceRequest(nullptr) {}
  ~DeleteEntranceRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DeleteEntranceRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DeleteEntranceRequest(const DeleteEntranceRequest& from);
  DeleteEntranceRequest(DeleteEntranceRequest&& from) noexcept
    : DeleteEntranceRequest() {
    *this = ::std::move(from);
  }

  inline DeleteEntranceRequest& operator=(const DeleteEntranceRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteEntranceRequest& operator=(DeleteEntranceRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DeleteEntranceRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeleteEntranceRequest* internal_default_instance() {
    return reinterpret_cast<const DeleteEntranceRequest*>(
               &_DeleteEntranceRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(DeleteEntranceRequest& a, DeleteEntranceRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteEntranceRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeleteEntranceRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DeleteEntranceRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteEntranceRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteEntranceRequest& from);
  void MergeFrom(const DeleteEntranceRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DeleteEntranceRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.DeleteEntranceRequest";
  }
  protected:
  explicit DeleteEntranceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOrponFieldNumber = 1,
    kEntranceNumberFieldNumber = 2,
  };
  // int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
  void clear_orpon() ;
  ::int64_t orpon() const;
  void set_orpon(::int64_t value);

  private:
  ::int64_t _internal_orpon() const;
  void _internal_set_orpon(::int64_t value);

  public:
  // int32 entrance_number = 2 [(.google.api.field_behavior) = REQUIRED];
  void clear_entrance_number() ;
  ::int32_t entrance_number() const;
  void set_entrance_number(::int32_t value);

  private:
  ::int32_t _internal_entrance_number() const;
  void _internal_set_entrance_number(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.DeleteEntranceRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::int64_t orpon_;
    ::int32_t entrance_number_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class DeleteEntranceResponse_Error_LinkedDevicesExists final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.DeleteEntranceResponse.Error.LinkedDevicesExists) */ {
 public:
  inline DeleteEntranceResponse_Error_LinkedDevicesExists() : DeleteEntranceResponse_Error_LinkedDevicesExists(nullptr) {}
  ~DeleteEntranceResponse_Error_LinkedDevicesExists() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DeleteEntranceResponse_Error_LinkedDevicesExists(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DeleteEntranceResponse_Error_LinkedDevicesExists(const DeleteEntranceResponse_Error_LinkedDevicesExists& from);
  DeleteEntranceResponse_Error_LinkedDevicesExists(DeleteEntranceResponse_Error_LinkedDevicesExists&& from) noexcept
    : DeleteEntranceResponse_Error_LinkedDevicesExists() {
    *this = ::std::move(from);
  }

  inline DeleteEntranceResponse_Error_LinkedDevicesExists& operator=(const DeleteEntranceResponse_Error_LinkedDevicesExists& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteEntranceResponse_Error_LinkedDevicesExists& operator=(DeleteEntranceResponse_Error_LinkedDevicesExists&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DeleteEntranceResponse_Error_LinkedDevicesExists& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeleteEntranceResponse_Error_LinkedDevicesExists* internal_default_instance() {
    return reinterpret_cast<const DeleteEntranceResponse_Error_LinkedDevicesExists*>(
               &_DeleteEntranceResponse_Error_LinkedDevicesExists_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(DeleteEntranceResponse_Error_LinkedDevicesExists& a, DeleteEntranceResponse_Error_LinkedDevicesExists& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteEntranceResponse_Error_LinkedDevicesExists* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeleteEntranceResponse_Error_LinkedDevicesExists* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DeleteEntranceResponse_Error_LinkedDevicesExists* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteEntranceResponse_Error_LinkedDevicesExists>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteEntranceResponse_Error_LinkedDevicesExists& from);
  void MergeFrom(const DeleteEntranceResponse_Error_LinkedDevicesExists& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DeleteEntranceResponse_Error_LinkedDevicesExists* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.DeleteEntranceResponse.Error.LinkedDevicesExists";
  }
  protected:
  explicit DeleteEntranceResponse_Error_LinkedDevicesExists(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.DeleteEntranceResponse.Error.LinkedDevicesExists)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class DeleteEntranceResponse_Error final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.DeleteEntranceResponse.Error) */ {
 public:
  inline DeleteEntranceResponse_Error() : DeleteEntranceResponse_Error(nullptr) {}
  ~DeleteEntranceResponse_Error() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DeleteEntranceResponse_Error(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DeleteEntranceResponse_Error(const DeleteEntranceResponse_Error& from);
  DeleteEntranceResponse_Error(DeleteEntranceResponse_Error&& from) noexcept
    : DeleteEntranceResponse_Error() {
    *this = ::std::move(from);
  }

  inline DeleteEntranceResponse_Error& operator=(const DeleteEntranceResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteEntranceResponse_Error& operator=(DeleteEntranceResponse_Error&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DeleteEntranceResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    kLinkedDevicesExists = 2,
    REASON_NOT_SET = 0,
  };

  static inline const DeleteEntranceResponse_Error* internal_default_instance() {
    return reinterpret_cast<const DeleteEntranceResponse_Error*>(
               &_DeleteEntranceResponse_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(DeleteEntranceResponse_Error& a, DeleteEntranceResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteEntranceResponse_Error* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeleteEntranceResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DeleteEntranceResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteEntranceResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteEntranceResponse_Error& from);
  void MergeFrom(const DeleteEntranceResponse_Error& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DeleteEntranceResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.DeleteEntranceResponse.Error";
  }
  protected:
  explicit DeleteEntranceResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef DeleteEntranceResponse_Error_LinkedDevicesExists LinkedDevicesExists;

  // accessors -------------------------------------------------------

  enum : int {
    kValidationFieldNumber = 1,
    kLinkedDevicesExistsFieldNumber = 2,
  };
  // .keyapis.access_control.v1.ValidationError validation = 1;
  bool has_validation() const;
  private:
  bool _internal_has_validation() const;

  public:
  void clear_validation() ;
  const ::keyapis::access_control::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::ValidationError* release_validation();
  ::keyapis::access_control::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation);
  private:
  const ::keyapis::access_control::v1::ValidationError& _internal_validation() const;
  ::keyapis::access_control::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::keyapis::access_control::v1::ValidationError* validation);
  ::keyapis::access_control::v1::ValidationError* unsafe_arena_release_validation();
  // .keyapis.access_control.v1.DeleteEntranceResponse.Error.LinkedDevicesExists linked_devices_exists = 2;
  bool has_linked_devices_exists() const;
  private:
  bool _internal_has_linked_devices_exists() const;

  public:
  void clear_linked_devices_exists() ;
  const ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists& linked_devices_exists() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* release_linked_devices_exists();
  ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* mutable_linked_devices_exists();
  void set_allocated_linked_devices_exists(::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* linked_devices_exists);
  private:
  const ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists& _internal_linked_devices_exists() const;
  ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* _internal_mutable_linked_devices_exists();
  public:
  void unsafe_arena_set_allocated_linked_devices_exists(
      ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* linked_devices_exists);
  ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* unsafe_arena_release_linked_devices_exists();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.DeleteEntranceResponse.Error)
 private:
  class _Internal;
  void set_has_validation();
  void set_has_linked_devices_exists();

  inline bool has_reason() const;
  inline void clear_has_reason();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::ValidationError* validation_;
      ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* linked_devices_exists_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class DeleteEntranceResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.DeleteEntranceResponse) */ {
 public:
  inline DeleteEntranceResponse() : DeleteEntranceResponse(nullptr) {}
  ~DeleteEntranceResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DeleteEntranceResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DeleteEntranceResponse(const DeleteEntranceResponse& from);
  DeleteEntranceResponse(DeleteEntranceResponse&& from) noexcept
    : DeleteEntranceResponse() {
    *this = ::std::move(from);
  }

  inline DeleteEntranceResponse& operator=(const DeleteEntranceResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteEntranceResponse& operator=(DeleteEntranceResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DeleteEntranceResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kError = 1,
    TYPE_NOT_SET = 0,
  };

  static inline const DeleteEntranceResponse* internal_default_instance() {
    return reinterpret_cast<const DeleteEntranceResponse*>(
               &_DeleteEntranceResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(DeleteEntranceResponse& a, DeleteEntranceResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteEntranceResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeleteEntranceResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DeleteEntranceResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteEntranceResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteEntranceResponse& from);
  void MergeFrom(const DeleteEntranceResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DeleteEntranceResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.DeleteEntranceResponse";
  }
  protected:
  explicit DeleteEntranceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef DeleteEntranceResponse_Error Error;

  // accessors -------------------------------------------------------

  enum : int {
    kErrorFieldNumber = 1,
  };
  // .keyapis.access_control.v1.DeleteEntranceResponse.Error error = 1;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::keyapis::access_control::v1::DeleteEntranceResponse_Error& error() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::DeleteEntranceResponse_Error* release_error();
  ::keyapis::access_control::v1::DeleteEntranceResponse_Error* mutable_error();
  void set_allocated_error(::keyapis::access_control::v1::DeleteEntranceResponse_Error* error);
  private:
  const ::keyapis::access_control::v1::DeleteEntranceResponse_Error& _internal_error() const;
  ::keyapis::access_control::v1::DeleteEntranceResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::keyapis::access_control::v1::DeleteEntranceResponse_Error* error);
  ::keyapis::access_control::v1::DeleteEntranceResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.DeleteEntranceResponse)
 private:
  class _Internal;
  void set_has_error();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::DeleteEntranceResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class EntranceDevice final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.EntranceDevice) */ {
 public:
  inline EntranceDevice() : EntranceDevice(nullptr) {}
  ~EntranceDevice() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EntranceDevice(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  EntranceDevice(const EntranceDevice& from);
  EntranceDevice(EntranceDevice&& from) noexcept
    : EntranceDevice() {
    *this = ::std::move(from);
  }

  inline EntranceDevice& operator=(const EntranceDevice& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntranceDevice& operator=(EntranceDevice&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const EntranceDevice& default_instance() {
    return *internal_default_instance();
  }
  static inline const EntranceDevice* internal_default_instance() {
    return reinterpret_cast<const EntranceDevice*>(
               &_EntranceDevice_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(EntranceDevice& a, EntranceDevice& b) {
    a.Swap(&b);
  }
  inline void Swap(EntranceDevice* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(EntranceDevice* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  EntranceDevice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntranceDevice>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const EntranceDevice& from);
  void MergeFrom(const EntranceDevice& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EntranceDevice* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.EntranceDevice";
  }
  protected:
  explicit EntranceDevice(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  using RelationType = EntranceDevice_RelationType;
  static constexpr RelationType RELATION_TYPE_UNKNOWN = EntranceDevice_RelationType_RELATION_TYPE_UNKNOWN;
  static constexpr RelationType FULL = EntranceDevice_RelationType_FULL;
  static constexpr RelationType PARTIAL = EntranceDevice_RelationType_PARTIAL;
  static inline bool RelationType_IsValid(int value) {
    return EntranceDevice_RelationType_IsValid(value);
  }
  static constexpr RelationType RelationType_MIN = EntranceDevice_RelationType_RelationType_MIN;
  static constexpr RelationType RelationType_MAX = EntranceDevice_RelationType_RelationType_MAX;
  static constexpr int RelationType_ARRAYSIZE = EntranceDevice_RelationType_RelationType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& RelationType_Name(T value) {
    return EntranceDevice_RelationType_Name(value);
  }
  static inline bool RelationType_Parse(absl::string_view name, RelationType* value) {
    return EntranceDevice_RelationType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kOrponFieldNumber = 1,
    kEntranceNumberFieldNumber = 2,
    kDeviceIdFieldNumber = 3,
    kRelationTypeFieldNumber = 4,
  };
  // int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
  void clear_orpon() ;
  ::int64_t orpon() const;
  void set_orpon(::int64_t value);

  private:
  ::int64_t _internal_orpon() const;
  void _internal_set_orpon(::int64_t value);

  public:
  // int32 entrance_number = 2 [(.google.api.field_behavior) = REQUIRED];
  void clear_entrance_number() ;
  ::int32_t entrance_number() const;
  void set_entrance_number(::int32_t value);

  private:
  ::int32_t _internal_entrance_number() const;
  void _internal_set_entrance_number(::int32_t value);

  public:
  // int32 device_id = 3 [(.google.api.field_behavior) = REQUIRED];
  void clear_device_id() ;
  ::int32_t device_id() const;
  void set_device_id(::int32_t value);

  private:
  ::int32_t _internal_device_id() const;
  void _internal_set_device_id(::int32_t value);

  public:
  // .keyapis.access_control.v1.EntranceDevice.RelationType relation_type = 4 [(.google.api.field_behavior) = OUTPUT_ONLY];
  void clear_relation_type() ;
  ::keyapis::access_control::v1::EntranceDevice_RelationType relation_type() const;
  void set_relation_type(::keyapis::access_control::v1::EntranceDevice_RelationType value);

  private:
  ::keyapis::access_control::v1::EntranceDevice_RelationType _internal_relation_type() const;
  void _internal_set_relation_type(::keyapis::access_control::v1::EntranceDevice_RelationType value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.EntranceDevice)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::int64_t orpon_;
    ::int32_t entrance_number_;
    ::int32_t device_id_;
    int relation_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class EntranceDeviceFilter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.EntranceDeviceFilter) */ {
 public:
  inline EntranceDeviceFilter() : EntranceDeviceFilter(nullptr) {}
  ~EntranceDeviceFilter() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EntranceDeviceFilter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  EntranceDeviceFilter(const EntranceDeviceFilter& from);
  EntranceDeviceFilter(EntranceDeviceFilter&& from) noexcept
    : EntranceDeviceFilter() {
    *this = ::std::move(from);
  }

  inline EntranceDeviceFilter& operator=(const EntranceDeviceFilter& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntranceDeviceFilter& operator=(EntranceDeviceFilter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const EntranceDeviceFilter& default_instance() {
    return *internal_default_instance();
  }
  static inline const EntranceDeviceFilter* internal_default_instance() {
    return reinterpret_cast<const EntranceDeviceFilter*>(
               &_EntranceDeviceFilter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(EntranceDeviceFilter& a, EntranceDeviceFilter& b) {
    a.Swap(&b);
  }
  inline void Swap(EntranceDeviceFilter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(EntranceDeviceFilter* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  EntranceDeviceFilter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntranceDeviceFilter>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const EntranceDeviceFilter& from);
  void MergeFrom(const EntranceDeviceFilter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EntranceDeviceFilter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.EntranceDeviceFilter";
  }
  protected:
  explicit EntranceDeviceFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlatgrammIdsFieldNumber = 1,
    kOrponsFieldNumber = 2,
    kEntranceNumbersFieldNumber = 3,
    kDeviceIdsFieldNumber = 4,
  };
  // repeated int32 flatgramm_ids = 1;
  int flatgramm_ids_size() const;
  private:
  int _internal_flatgramm_ids_size() const;

  public:
  void clear_flatgramm_ids() ;
  ::int32_t flatgramm_ids(int index) const;
  void set_flatgramm_ids(int index, ::int32_t value);
  void add_flatgramm_ids(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& flatgramm_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* mutable_flatgramm_ids();

  private:
  ::int32_t _internal_flatgramm_ids(int index) const;
  void _internal_add_flatgramm_ids(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& _internal_flatgramm_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* _internal_mutable_flatgramm_ids();

  public:
  // repeated int64 orpons = 2;
  int orpons_size() const;
  private:
  int _internal_orpons_size() const;

  public:
  void clear_orpons() ;
  ::int64_t orpons(int index) const;
  void set_orpons(int index, ::int64_t value);
  void add_orpons(::int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>& orpons() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>* mutable_orpons();

  private:
  ::int64_t _internal_orpons(int index) const;
  void _internal_add_orpons(::int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>& _internal_orpons() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>* _internal_mutable_orpons();

  public:
  // repeated int32 entrance_numbers = 3;
  int entrance_numbers_size() const;
  private:
  int _internal_entrance_numbers_size() const;

  public:
  void clear_entrance_numbers() ;
  ::int32_t entrance_numbers(int index) const;
  void set_entrance_numbers(int index, ::int32_t value);
  void add_entrance_numbers(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& entrance_numbers() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* mutable_entrance_numbers();

  private:
  ::int32_t _internal_entrance_numbers(int index) const;
  void _internal_add_entrance_numbers(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& _internal_entrance_numbers() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* _internal_mutable_entrance_numbers();

  public:
  // repeated int32 device_ids = 4;
  int device_ids_size() const;
  private:
  int _internal_device_ids_size() const;

  public:
  void clear_device_ids() ;
  ::int32_t device_ids(int index) const;
  void set_device_ids(int index, ::int32_t value);
  void add_device_ids(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& device_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* mutable_device_ids();

  private:
  ::int32_t _internal_device_ids(int index) const;
  void _internal_add_device_ids(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& _internal_device_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* _internal_mutable_device_ids();

  public:
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.EntranceDeviceFilter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t> flatgramm_ids_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _flatgramm_ids_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t> orpons_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _orpons_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t> entrance_numbers_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _entrance_numbers_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t> device_ids_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _device_ids_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class EntranceDevicePaging final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.EntranceDevicePaging) */ {
 public:
  inline EntranceDevicePaging() : EntranceDevicePaging(nullptr) {}
  ~EntranceDevicePaging() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EntranceDevicePaging(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  EntranceDevicePaging(const EntranceDevicePaging& from);
  EntranceDevicePaging(EntranceDevicePaging&& from) noexcept
    : EntranceDevicePaging() {
    *this = ::std::move(from);
  }

  inline EntranceDevicePaging& operator=(const EntranceDevicePaging& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntranceDevicePaging& operator=(EntranceDevicePaging&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const EntranceDevicePaging& default_instance() {
    return *internal_default_instance();
  }
  static inline const EntranceDevicePaging* internal_default_instance() {
    return reinterpret_cast<const EntranceDevicePaging*>(
               &_EntranceDevicePaging_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(EntranceDevicePaging& a, EntranceDevicePaging& b) {
    a.Swap(&b);
  }
  inline void Swap(EntranceDevicePaging* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(EntranceDevicePaging* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  EntranceDevicePaging* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntranceDevicePaging>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const EntranceDevicePaging& from);
  void MergeFrom(const EntranceDevicePaging& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EntranceDevicePaging* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.EntranceDevicePaging";
  }
  protected:
  explicit EntranceDevicePaging(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  using OrderByType = EntranceDevicePaging_OrderByType;
  static constexpr OrderByType ORDER_BY_TYPE_UNKNOWN = EntranceDevicePaging_OrderByType_ORDER_BY_TYPE_UNKNOWN;
  static constexpr OrderByType ORPON_THEN_ENTRANCE_NUMBER = EntranceDevicePaging_OrderByType_ORPON_THEN_ENTRANCE_NUMBER;
  static constexpr OrderByType DEVICE_ID = EntranceDevicePaging_OrderByType_DEVICE_ID;
  static inline bool OrderByType_IsValid(int value) {
    return EntranceDevicePaging_OrderByType_IsValid(value);
  }
  static constexpr OrderByType OrderByType_MIN = EntranceDevicePaging_OrderByType_OrderByType_MIN;
  static constexpr OrderByType OrderByType_MAX = EntranceDevicePaging_OrderByType_OrderByType_MAX;
  static constexpr int OrderByType_ARRAYSIZE = EntranceDevicePaging_OrderByType_OrderByType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& OrderByType_Name(T value) {
    return EntranceDevicePaging_OrderByType_Name(value);
  }
  static inline bool OrderByType_Parse(absl::string_view name, OrderByType* value) {
    return EntranceDevicePaging_OrderByType_Parse(name, value);
  }

  using DirectionType = EntranceDevicePaging_DirectionType;
  static constexpr DirectionType DIRECTION_TYPE_UNKNOWN = EntranceDevicePaging_DirectionType_DIRECTION_TYPE_UNKNOWN;
  static constexpr DirectionType DESC = EntranceDevicePaging_DirectionType_DESC;
  static constexpr DirectionType ASC = EntranceDevicePaging_DirectionType_ASC;
  static inline bool DirectionType_IsValid(int value) {
    return EntranceDevicePaging_DirectionType_IsValid(value);
  }
  static constexpr DirectionType DirectionType_MIN = EntranceDevicePaging_DirectionType_DirectionType_MIN;
  static constexpr DirectionType DirectionType_MAX = EntranceDevicePaging_DirectionType_DirectionType_MAX;
  static constexpr int DirectionType_ARRAYSIZE = EntranceDevicePaging_DirectionType_DirectionType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& DirectionType_Name(T value) {
    return EntranceDevicePaging_DirectionType_Name(value);
  }
  static inline bool DirectionType_Parse(absl::string_view name, DirectionType* value) {
    return EntranceDevicePaging_DirectionType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kOrderByTypeFieldNumber = 1,
    kDirectionTypeFieldNumber = 2,
    kLimitFieldNumber = 3,
    kOffsetFieldNumber = 4,
  };
  // .keyapis.access_control.v1.EntranceDevicePaging.OrderByType order_by_type = 1;
  void clear_order_by_type() ;
  ::keyapis::access_control::v1::EntranceDevicePaging_OrderByType order_by_type() const;
  void set_order_by_type(::keyapis::access_control::v1::EntranceDevicePaging_OrderByType value);

  private:
  ::keyapis::access_control::v1::EntranceDevicePaging_OrderByType _internal_order_by_type() const;
  void _internal_set_order_by_type(::keyapis::access_control::v1::EntranceDevicePaging_OrderByType value);

  public:
  // .keyapis.access_control.v1.EntranceDevicePaging.DirectionType direction_type = 2;
  void clear_direction_type() ;
  ::keyapis::access_control::v1::EntranceDevicePaging_DirectionType direction_type() const;
  void set_direction_type(::keyapis::access_control::v1::EntranceDevicePaging_DirectionType value);

  private:
  ::keyapis::access_control::v1::EntranceDevicePaging_DirectionType _internal_direction_type() const;
  void _internal_set_direction_type(::keyapis::access_control::v1::EntranceDevicePaging_DirectionType value);

  public:
  // int32 limit = 3;
  void clear_limit() ;
  ::int32_t limit() const;
  void set_limit(::int32_t value);

  private:
  ::int32_t _internal_limit() const;
  void _internal_set_limit(::int32_t value);

  public:
  // int32 offset = 4;
  void clear_offset() ;
  ::int32_t offset() const;
  void set_offset(::int32_t value);

  private:
  ::int32_t _internal_offset() const;
  void _internal_set_offset(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.EntranceDevicePaging)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int order_by_type_;
    int direction_type_;
    ::int32_t limit_;
    ::int32_t offset_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetEntranceDeviceListRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.GetEntranceDeviceListRequest) */ {
 public:
  inline GetEntranceDeviceListRequest() : GetEntranceDeviceListRequest(nullptr) {}
  ~GetEntranceDeviceListRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetEntranceDeviceListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetEntranceDeviceListRequest(const GetEntranceDeviceListRequest& from);
  GetEntranceDeviceListRequest(GetEntranceDeviceListRequest&& from) noexcept
    : GetEntranceDeviceListRequest() {
    *this = ::std::move(from);
  }

  inline GetEntranceDeviceListRequest& operator=(const GetEntranceDeviceListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetEntranceDeviceListRequest& operator=(GetEntranceDeviceListRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetEntranceDeviceListRequest& default_instance() {
    return *internal_default_instance();
  }
  enum PaginationCase {
    kPaging = 2,
    PAGINATION_NOT_SET = 0,
  };

  static inline const GetEntranceDeviceListRequest* internal_default_instance() {
    return reinterpret_cast<const GetEntranceDeviceListRequest*>(
               &_GetEntranceDeviceListRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(GetEntranceDeviceListRequest& a, GetEntranceDeviceListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetEntranceDeviceListRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetEntranceDeviceListRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetEntranceDeviceListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetEntranceDeviceListRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetEntranceDeviceListRequest& from);
  void MergeFrom(const GetEntranceDeviceListRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetEntranceDeviceListRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.GetEntranceDeviceListRequest";
  }
  protected:
  explicit GetEntranceDeviceListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFilterFieldNumber = 1,
    kPagingFieldNumber = 2,
  };
  // .keyapis.access_control.v1.EntranceDeviceFilter filter = 1;
  bool has_filter() const;
  void clear_filter() ;
  const ::keyapis::access_control::v1::EntranceDeviceFilter& filter() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::EntranceDeviceFilter* release_filter();
  ::keyapis::access_control::v1::EntranceDeviceFilter* mutable_filter();
  void set_allocated_filter(::keyapis::access_control::v1::EntranceDeviceFilter* filter);
  private:
  const ::keyapis::access_control::v1::EntranceDeviceFilter& _internal_filter() const;
  ::keyapis::access_control::v1::EntranceDeviceFilter* _internal_mutable_filter();
  public:
  void unsafe_arena_set_allocated_filter(
      ::keyapis::access_control::v1::EntranceDeviceFilter* filter);
  ::keyapis::access_control::v1::EntranceDeviceFilter* unsafe_arena_release_filter();
  // .keyapis.access_control.v1.EntranceDevicePaging paging = 2;
  bool has_paging() const;
  private:
  bool _internal_has_paging() const;

  public:
  void clear_paging() ;
  const ::keyapis::access_control::v1::EntranceDevicePaging& paging() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::EntranceDevicePaging* release_paging();
  ::keyapis::access_control::v1::EntranceDevicePaging* mutable_paging();
  void set_allocated_paging(::keyapis::access_control::v1::EntranceDevicePaging* paging);
  private:
  const ::keyapis::access_control::v1::EntranceDevicePaging& _internal_paging() const;
  ::keyapis::access_control::v1::EntranceDevicePaging* _internal_mutable_paging();
  public:
  void unsafe_arena_set_allocated_paging(
      ::keyapis::access_control::v1::EntranceDevicePaging* paging);
  ::keyapis::access_control::v1::EntranceDevicePaging* unsafe_arena_release_paging();
  void clear_pagination();
  PaginationCase pagination_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.GetEntranceDeviceListRequest)
 private:
  class _Internal;
  void set_has_paging();

  inline bool has_pagination() const;
  inline void clear_has_pagination();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::keyapis::access_control::v1::EntranceDeviceFilter* filter_;
    union PaginationUnion {
      constexpr PaginationUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::EntranceDevicePaging* paging_;
    } pagination_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetEntranceDeviceListResponse_Error final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.GetEntranceDeviceListResponse.Error) */ {
 public:
  inline GetEntranceDeviceListResponse_Error() : GetEntranceDeviceListResponse_Error(nullptr) {}
  ~GetEntranceDeviceListResponse_Error() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetEntranceDeviceListResponse_Error(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetEntranceDeviceListResponse_Error(const GetEntranceDeviceListResponse_Error& from);
  GetEntranceDeviceListResponse_Error(GetEntranceDeviceListResponse_Error&& from) noexcept
    : GetEntranceDeviceListResponse_Error() {
    *this = ::std::move(from);
  }

  inline GetEntranceDeviceListResponse_Error& operator=(const GetEntranceDeviceListResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetEntranceDeviceListResponse_Error& operator=(GetEntranceDeviceListResponse_Error&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetEntranceDeviceListResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

  static inline const GetEntranceDeviceListResponse_Error* internal_default_instance() {
    return reinterpret_cast<const GetEntranceDeviceListResponse_Error*>(
               &_GetEntranceDeviceListResponse_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(GetEntranceDeviceListResponse_Error& a, GetEntranceDeviceListResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(GetEntranceDeviceListResponse_Error* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetEntranceDeviceListResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetEntranceDeviceListResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetEntranceDeviceListResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetEntranceDeviceListResponse_Error& from);
  void MergeFrom(const GetEntranceDeviceListResponse_Error& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetEntranceDeviceListResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.GetEntranceDeviceListResponse.Error";
  }
  protected:
  explicit GetEntranceDeviceListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValidationFieldNumber = 1,
  };
  // .keyapis.access_control.v1.ValidationError validation = 1;
  bool has_validation() const;
  private:
  bool _internal_has_validation() const;

  public:
  void clear_validation() ;
  const ::keyapis::access_control::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::ValidationError* release_validation();
  ::keyapis::access_control::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation);
  private:
  const ::keyapis::access_control::v1::ValidationError& _internal_validation() const;
  ::keyapis::access_control::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::keyapis::access_control::v1::ValidationError* validation);
  ::keyapis::access_control::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.GetEntranceDeviceListResponse.Error)
 private:
  class _Internal;
  void set_has_validation();

  inline bool has_reason() const;
  inline void clear_has_reason();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetEntranceDeviceListResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.access_control.v1.GetEntranceDeviceListResponse) */ {
 public:
  inline GetEntranceDeviceListResponse() : GetEntranceDeviceListResponse(nullptr) {}
  ~GetEntranceDeviceListResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetEntranceDeviceListResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetEntranceDeviceListResponse(const GetEntranceDeviceListResponse& from);
  GetEntranceDeviceListResponse(GetEntranceDeviceListResponse&& from) noexcept
    : GetEntranceDeviceListResponse() {
    *this = ::std::move(from);
  }

  inline GetEntranceDeviceListResponse& operator=(const GetEntranceDeviceListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetEntranceDeviceListResponse& operator=(GetEntranceDeviceListResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetEntranceDeviceListResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    kError = 2,
    TYPE_NOT_SET = 0,
  };

  static inline const GetEntranceDeviceListResponse* internal_default_instance() {
    return reinterpret_cast<const GetEntranceDeviceListResponse*>(
               &_GetEntranceDeviceListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(GetEntranceDeviceListResponse& a, GetEntranceDeviceListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetEntranceDeviceListResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetEntranceDeviceListResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetEntranceDeviceListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetEntranceDeviceListResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetEntranceDeviceListResponse& from);
  void MergeFrom(const GetEntranceDeviceListResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetEntranceDeviceListResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.access_control.v1.GetEntranceDeviceListResponse";
  }
  protected:
  explicit GetEntranceDeviceListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef GetEntranceDeviceListResponse_Error Error;

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
    kErrorFieldNumber = 2,
  };
  // .keyapis.access_control.v1.EntranceDevice data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::keyapis::access_control::v1::EntranceDevice& data() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::EntranceDevice* release_data();
  ::keyapis::access_control::v1::EntranceDevice* mutable_data();
  void set_allocated_data(::keyapis::access_control::v1::EntranceDevice* data);
  private:
  const ::keyapis::access_control::v1::EntranceDevice& _internal_data() const;
  ::keyapis::access_control::v1::EntranceDevice* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::keyapis::access_control::v1::EntranceDevice* data);
  ::keyapis::access_control::v1::EntranceDevice* unsafe_arena_release_data();
  // .keyapis.access_control.v1.GetEntranceDeviceListResponse.Error error = 2;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error& error() const;
  PROTOBUF_NODISCARD ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* release_error();
  ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* mutable_error();
  void set_allocated_error(::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* error);
  private:
  const ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error& _internal_error() const;
  ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* error);
  ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.access_control.v1.GetEntranceDeviceListResponse)
 private:
  class _Internal;
  void set_has_data();
  void set_has_error();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::access_control::v1::EntranceDevice* data_;
      ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto;
};

// ===================================================================




// ===================================================================


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// Entrance

// int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
inline void Entrance::clear_orpon() {
  _impl_.orpon_ = ::int64_t{0};
}
inline ::int64_t Entrance::orpon() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.Entrance.orpon)
  return _internal_orpon();
}
inline void Entrance::set_orpon(::int64_t value) {
  _internal_set_orpon(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.Entrance.orpon)
}
inline ::int64_t Entrance::_internal_orpon() const {
  return _impl_.orpon_;
}
inline void Entrance::_internal_set_orpon(::int64_t value) {
  ;
  _impl_.orpon_ = value;
}

// int32 entrance_number = 2 [(.google.api.field_behavior) = REQUIRED];
inline void Entrance::clear_entrance_number() {
  _impl_.entrance_number_ = 0;
}
inline ::int32_t Entrance::entrance_number() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.Entrance.entrance_number)
  return _internal_entrance_number();
}
inline void Entrance::set_entrance_number(::int32_t value) {
  _internal_set_entrance_number(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.Entrance.entrance_number)
}
inline ::int32_t Entrance::_internal_entrance_number() const {
  return _impl_.entrance_number_;
}
inline void Entrance::_internal_set_entrance_number(::int32_t value) {
  ;
  _impl_.entrance_number_ = value;
}

// int32 start_room_number = 3 [(.google.api.field_behavior) = REQUIRED];
inline void Entrance::clear_start_room_number() {
  _impl_.start_room_number_ = 0;
}
inline ::int32_t Entrance::start_room_number() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.Entrance.start_room_number)
  return _internal_start_room_number();
}
inline void Entrance::set_start_room_number(::int32_t value) {
  _internal_set_start_room_number(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.Entrance.start_room_number)
}
inline ::int32_t Entrance::_internal_start_room_number() const {
  return _impl_.start_room_number_;
}
inline void Entrance::_internal_set_start_room_number(::int32_t value) {
  ;
  _impl_.start_room_number_ = value;
}

// int32 rooms_count_per_floor = 4 [(.google.api.field_behavior) = REQUIRED];
inline void Entrance::clear_rooms_count_per_floor() {
  _impl_.rooms_count_per_floor_ = 0;
}
inline ::int32_t Entrance::rooms_count_per_floor() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.Entrance.rooms_count_per_floor)
  return _internal_rooms_count_per_floor();
}
inline void Entrance::set_rooms_count_per_floor(::int32_t value) {
  _internal_set_rooms_count_per_floor(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.Entrance.rooms_count_per_floor)
}
inline ::int32_t Entrance::_internal_rooms_count_per_floor() const {
  return _impl_.rooms_count_per_floor_;
}
inline void Entrance::_internal_set_rooms_count_per_floor(::int32_t value) {
  ;
  _impl_.rooms_count_per_floor_ = value;
}

// int32 floors_count = 5 [(.google.api.field_behavior) = REQUIRED];
inline void Entrance::clear_floors_count() {
  _impl_.floors_count_ = 0;
}
inline ::int32_t Entrance::floors_count() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.Entrance.floors_count)
  return _internal_floors_count();
}
inline void Entrance::set_floors_count(::int32_t value) {
  _internal_set_floors_count(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.Entrance.floors_count)
}
inline ::int32_t Entrance::_internal_floors_count() const {
  return _impl_.floors_count_;
}
inline void Entrance::_internal_set_floors_count(::int32_t value) {
  ;
  _impl_.floors_count_ = value;
}

// -------------------------------------------------------------------

// EntranceFilter

// repeated int32 flatgramm_ids = 1;
inline int EntranceFilter::_internal_flatgramm_ids_size() const {
  return _impl_.flatgramm_ids_.size();
}
inline int EntranceFilter::flatgramm_ids_size() const {
  return _internal_flatgramm_ids_size();
}
inline void EntranceFilter::clear_flatgramm_ids() {
  _internal_mutable_flatgramm_ids()->Clear();
}
inline ::int32_t EntranceFilter::flatgramm_ids(int index) const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceFilter.flatgramm_ids)
  return _internal_flatgramm_ids(index);
}
inline void EntranceFilter::set_flatgramm_ids(int index, ::int32_t value) {
  _internal_mutable_flatgramm_ids()->Set(index, value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceFilter.flatgramm_ids)
}
inline void EntranceFilter::add_flatgramm_ids(::int32_t value) {
  _internal_add_flatgramm_ids(value);
  // @@protoc_insertion_point(field_add:keyapis.access_control.v1.EntranceFilter.flatgramm_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceFilter::flatgramm_ids() const {
  // @@protoc_insertion_point(field_list:keyapis.access_control.v1.EntranceFilter.flatgramm_ids)
  return _internal_flatgramm_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceFilter::mutable_flatgramm_ids() {
  // @@protoc_insertion_point(field_mutable_list:keyapis.access_control.v1.EntranceFilter.flatgramm_ids)
  return _internal_mutable_flatgramm_ids();
}

inline ::int32_t EntranceFilter::_internal_flatgramm_ids(int index) const {
  return _internal_flatgramm_ids().Get(index);
}
inline void EntranceFilter::_internal_add_flatgramm_ids(::int32_t value) {
  _internal_mutable_flatgramm_ids()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceFilter::_internal_flatgramm_ids() const {
  return _impl_.flatgramm_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceFilter::_internal_mutable_flatgramm_ids() {
  return &_impl_.flatgramm_ids_;
}

// repeated int64 orpons = 2;
inline int EntranceFilter::_internal_orpons_size() const {
  return _impl_.orpons_.size();
}
inline int EntranceFilter::orpons_size() const {
  return _internal_orpons_size();
}
inline void EntranceFilter::clear_orpons() {
  _internal_mutable_orpons()->Clear();
}
inline ::int64_t EntranceFilter::orpons(int index) const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceFilter.orpons)
  return _internal_orpons(index);
}
inline void EntranceFilter::set_orpons(int index, ::int64_t value) {
  _internal_mutable_orpons()->Set(index, value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceFilter.orpons)
}
inline void EntranceFilter::add_orpons(::int64_t value) {
  _internal_add_orpons(value);
  // @@protoc_insertion_point(field_add:keyapis.access_control.v1.EntranceFilter.orpons)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>& EntranceFilter::orpons() const {
  // @@protoc_insertion_point(field_list:keyapis.access_control.v1.EntranceFilter.orpons)
  return _internal_orpons();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>* EntranceFilter::mutable_orpons() {
  // @@protoc_insertion_point(field_mutable_list:keyapis.access_control.v1.EntranceFilter.orpons)
  return _internal_mutable_orpons();
}

inline ::int64_t EntranceFilter::_internal_orpons(int index) const {
  return _internal_orpons().Get(index);
}
inline void EntranceFilter::_internal_add_orpons(::int64_t value) {
  _internal_mutable_orpons()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>& EntranceFilter::_internal_orpons() const {
  return _impl_.orpons_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>* EntranceFilter::_internal_mutable_orpons() {
  return &_impl_.orpons_;
}

// repeated int32 company_ids = 3;
inline int EntranceFilter::_internal_company_ids_size() const {
  return _impl_.company_ids_.size();
}
inline int EntranceFilter::company_ids_size() const {
  return _internal_company_ids_size();
}
inline void EntranceFilter::clear_company_ids() {
  _internal_mutable_company_ids()->Clear();
}
inline ::int32_t EntranceFilter::company_ids(int index) const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceFilter.company_ids)
  return _internal_company_ids(index);
}
inline void EntranceFilter::set_company_ids(int index, ::int32_t value) {
  _internal_mutable_company_ids()->Set(index, value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceFilter.company_ids)
}
inline void EntranceFilter::add_company_ids(::int32_t value) {
  _internal_add_company_ids(value);
  // @@protoc_insertion_point(field_add:keyapis.access_control.v1.EntranceFilter.company_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceFilter::company_ids() const {
  // @@protoc_insertion_point(field_list:keyapis.access_control.v1.EntranceFilter.company_ids)
  return _internal_company_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceFilter::mutable_company_ids() {
  // @@protoc_insertion_point(field_mutable_list:keyapis.access_control.v1.EntranceFilter.company_ids)
  return _internal_mutable_company_ids();
}

inline ::int32_t EntranceFilter::_internal_company_ids(int index) const {
  return _internal_company_ids().Get(index);
}
inline void EntranceFilter::_internal_add_company_ids(::int32_t value) {
  _internal_mutable_company_ids()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceFilter::_internal_company_ids() const {
  return _impl_.company_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceFilter::_internal_mutable_company_ids() {
  return &_impl_.company_ids_;
}

// .keyapis.access_control.v1.EntranceFilter.CompanyRelationType company_relation_type = 4;
inline void EntranceFilter::clear_company_relation_type() {
  _impl_.company_relation_type_ = 0;
}
inline ::keyapis::access_control::v1::EntranceFilter_CompanyRelationType EntranceFilter::company_relation_type() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceFilter.company_relation_type)
  return _internal_company_relation_type();
}
inline void EntranceFilter::set_company_relation_type(::keyapis::access_control::v1::EntranceFilter_CompanyRelationType value) {
   _internal_set_company_relation_type(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceFilter.company_relation_type)
}
inline ::keyapis::access_control::v1::EntranceFilter_CompanyRelationType EntranceFilter::_internal_company_relation_type() const {
  return static_cast<::keyapis::access_control::v1::EntranceFilter_CompanyRelationType>(_impl_.company_relation_type_);
}
inline void EntranceFilter::_internal_set_company_relation_type(::keyapis::access_control::v1::EntranceFilter_CompanyRelationType value) {
  ;
  _impl_.company_relation_type_ = value;
}

// -------------------------------------------------------------------

// EntrancePaging

// .keyapis.access_control.v1.EntrancePaging.OrderByType order_by_type = 1;
inline void EntrancePaging::clear_order_by_type() {
  _impl_.order_by_type_ = 0;
}
inline ::keyapis::access_control::v1::EntrancePaging_OrderByType EntrancePaging::order_by_type() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntrancePaging.order_by_type)
  return _internal_order_by_type();
}
inline void EntrancePaging::set_order_by_type(::keyapis::access_control::v1::EntrancePaging_OrderByType value) {
   _internal_set_order_by_type(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntrancePaging.order_by_type)
}
inline ::keyapis::access_control::v1::EntrancePaging_OrderByType EntrancePaging::_internal_order_by_type() const {
  return static_cast<::keyapis::access_control::v1::EntrancePaging_OrderByType>(_impl_.order_by_type_);
}
inline void EntrancePaging::_internal_set_order_by_type(::keyapis::access_control::v1::EntrancePaging_OrderByType value) {
  ;
  _impl_.order_by_type_ = value;
}

// .keyapis.access_control.v1.EntrancePaging.DirectionType direction_type = 2;
inline void EntrancePaging::clear_direction_type() {
  _impl_.direction_type_ = 0;
}
inline ::keyapis::access_control::v1::EntrancePaging_DirectionType EntrancePaging::direction_type() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntrancePaging.direction_type)
  return _internal_direction_type();
}
inline void EntrancePaging::set_direction_type(::keyapis::access_control::v1::EntrancePaging_DirectionType value) {
   _internal_set_direction_type(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntrancePaging.direction_type)
}
inline ::keyapis::access_control::v1::EntrancePaging_DirectionType EntrancePaging::_internal_direction_type() const {
  return static_cast<::keyapis::access_control::v1::EntrancePaging_DirectionType>(_impl_.direction_type_);
}
inline void EntrancePaging::_internal_set_direction_type(::keyapis::access_control::v1::EntrancePaging_DirectionType value) {
  ;
  _impl_.direction_type_ = value;
}

// int32 limit = 3;
inline void EntrancePaging::clear_limit() {
  _impl_.limit_ = 0;
}
inline ::int32_t EntrancePaging::limit() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntrancePaging.limit)
  return _internal_limit();
}
inline void EntrancePaging::set_limit(::int32_t value) {
  _internal_set_limit(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntrancePaging.limit)
}
inline ::int32_t EntrancePaging::_internal_limit() const {
  return _impl_.limit_;
}
inline void EntrancePaging::_internal_set_limit(::int32_t value) {
  ;
  _impl_.limit_ = value;
}

// int32 offset = 4;
inline void EntrancePaging::clear_offset() {
  _impl_.offset_ = 0;
}
inline ::int32_t EntrancePaging::offset() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntrancePaging.offset)
  return _internal_offset();
}
inline void EntrancePaging::set_offset(::int32_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntrancePaging.offset)
}
inline ::int32_t EntrancePaging::_internal_offset() const {
  return _impl_.offset_;
}
inline void EntrancePaging::_internal_set_offset(::int32_t value) {
  ;
  _impl_.offset_ = value;
}

// -------------------------------------------------------------------

// GetEntranceListRequest

// .keyapis.access_control.v1.EntranceFilter filter = 1;
inline bool GetEntranceListRequest::has_filter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.filter_ != nullptr);
  return value;
}
inline void GetEntranceListRequest::clear_filter() {
  if (_impl_.filter_ != nullptr) _impl_.filter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::keyapis::access_control::v1::EntranceFilter& GetEntranceListRequest::_internal_filter() const {
  const ::keyapis::access_control::v1::EntranceFilter* p = _impl_.filter_;
  return p != nullptr ? *p : reinterpret_cast<const ::keyapis::access_control::v1::EntranceFilter&>(
      ::keyapis::access_control::v1::_EntranceFilter_default_instance_);
}
inline const ::keyapis::access_control::v1::EntranceFilter& GetEntranceListRequest::filter() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceListRequest.filter)
  return _internal_filter();
}
inline void GetEntranceListRequest::unsafe_arena_set_allocated_filter(
    ::keyapis::access_control::v1::EntranceFilter* filter) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.filter_);
  }
  _impl_.filter_ = filter;
  if (filter) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceListRequest.filter)
}
inline ::keyapis::access_control::v1::EntranceFilter* GetEntranceListRequest::release_filter() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::EntranceFilter* temp = _impl_.filter_;
  _impl_.filter_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::keyapis::access_control::v1::EntranceFilter* GetEntranceListRequest::unsafe_arena_release_filter() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceListRequest.filter)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::EntranceFilter* temp = _impl_.filter_;
  _impl_.filter_ = nullptr;
  return temp;
}
inline ::keyapis::access_control::v1::EntranceFilter* GetEntranceListRequest::_internal_mutable_filter() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.filter_ == nullptr) {
    auto* p = CreateMaybeMessage<::keyapis::access_control::v1::EntranceFilter>(GetArenaForAllocation());
    _impl_.filter_ = p;
  }
  return _impl_.filter_;
}
inline ::keyapis::access_control::v1::EntranceFilter* GetEntranceListRequest::mutable_filter() {
  ::keyapis::access_control::v1::EntranceFilter* _msg = _internal_mutable_filter();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceListRequest.filter)
  return _msg;
}
inline void GetEntranceListRequest::set_allocated_filter(::keyapis::access_control::v1::EntranceFilter* filter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.filter_;
  }
  if (filter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(filter);
    if (message_arena != submessage_arena) {
      filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filter, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.filter_ = filter;
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.GetEntranceListRequest.filter)
}

// .keyapis.access_control.v1.EntrancePaging paging = 2;
inline bool GetEntranceListRequest::has_paging() const {
  return pagination_case() == kPaging;
}
inline bool GetEntranceListRequest::_internal_has_paging() const {
  return pagination_case() == kPaging;
}
inline void GetEntranceListRequest::set_has_paging() {
  _impl_._oneof_case_[0] = kPaging;
}
inline void GetEntranceListRequest::clear_paging() {
  if (pagination_case() == kPaging) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.pagination_.paging_;
    }
    clear_has_pagination();
  }
}
inline ::keyapis::access_control::v1::EntrancePaging* GetEntranceListRequest::release_paging() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceListRequest.paging)
  if (pagination_case() == kPaging) {
    clear_has_pagination();
    ::keyapis::access_control::v1::EntrancePaging* temp = _impl_.pagination_.paging_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.pagination_.paging_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::EntrancePaging& GetEntranceListRequest::_internal_paging() const {
  return pagination_case() == kPaging
      ? *_impl_.pagination_.paging_
      : reinterpret_cast<::keyapis::access_control::v1::EntrancePaging&>(::keyapis::access_control::v1::_EntrancePaging_default_instance_);
}
inline const ::keyapis::access_control::v1::EntrancePaging& GetEntranceListRequest::paging() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceListRequest.paging)
  return _internal_paging();
}
inline ::keyapis::access_control::v1::EntrancePaging* GetEntranceListRequest::unsafe_arena_release_paging() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.GetEntranceListRequest.paging)
  if (pagination_case() == kPaging) {
    clear_has_pagination();
    ::keyapis::access_control::v1::EntrancePaging* temp = _impl_.pagination_.paging_;
    _impl_.pagination_.paging_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetEntranceListRequest::unsafe_arena_set_allocated_paging(::keyapis::access_control::v1::EntrancePaging* paging) {
  clear_pagination();
  if (paging) {
    set_has_paging();
    _impl_.pagination_.paging_ = paging;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceListRequest.paging)
}
inline ::keyapis::access_control::v1::EntrancePaging* GetEntranceListRequest::_internal_mutable_paging() {
  if (pagination_case() != kPaging) {
    clear_pagination();
    set_has_paging();
    _impl_.pagination_.paging_ = CreateMaybeMessage< ::keyapis::access_control::v1::EntrancePaging >(GetArenaForAllocation());
  }
  return _impl_.pagination_.paging_;
}
inline ::keyapis::access_control::v1::EntrancePaging* GetEntranceListRequest::mutable_paging() {
  ::keyapis::access_control::v1::EntrancePaging* _msg = _internal_mutable_paging();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceListRequest.paging)
  return _msg;
}

inline bool GetEntranceListRequest::has_pagination() const {
  return pagination_case() != PAGINATION_NOT_SET;
}
inline void GetEntranceListRequest::clear_has_pagination() {
  _impl_._oneof_case_[0] = PAGINATION_NOT_SET;
}
inline GetEntranceListRequest::PaginationCase GetEntranceListRequest::pagination_case() const {
  return GetEntranceListRequest::PaginationCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetEntranceListResponse_Error

// .keyapis.access_control.v1.ValidationError validation = 1;
inline bool GetEntranceListResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool GetEntranceListResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void GetEntranceListResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::keyapis::access_control::v1::ValidationError* GetEntranceListResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceListResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::ValidationError& GetEntranceListResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::keyapis::access_control::v1::ValidationError&>(::keyapis::access_control::v1::_ValidationError_default_instance_);
}
inline const ::keyapis::access_control::v1::ValidationError& GetEntranceListResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceListResponse.Error.validation)
  return _internal_validation();
}
inline ::keyapis::access_control::v1::ValidationError* GetEntranceListResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.GetEntranceListResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetEntranceListResponse_Error::unsafe_arena_set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceListResponse.Error.validation)
}
inline ::keyapis::access_control::v1::ValidationError* GetEntranceListResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::keyapis::access_control::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::keyapis::access_control::v1::ValidationError* GetEntranceListResponse_Error::mutable_validation() {
  ::keyapis::access_control::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceListResponse.Error.validation)
  return _msg;
}

inline bool GetEntranceListResponse_Error::has_reason() const {
  return reason_case() != REASON_NOT_SET;
}
inline void GetEntranceListResponse_Error::clear_has_reason() {
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}
inline GetEntranceListResponse_Error::ReasonCase GetEntranceListResponse_Error::reason_case() const {
  return GetEntranceListResponse_Error::ReasonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetEntranceListResponse

// .keyapis.access_control.v1.Entrance data = 1;
inline bool GetEntranceListResponse::has_data() const {
  return type_case() == kData;
}
inline bool GetEntranceListResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void GetEntranceListResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void GetEntranceListResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::Entrance* GetEntranceListResponse::release_data() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceListResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::access_control::v1::Entrance* temp = _impl_.type_.data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::Entrance& GetEntranceListResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::keyapis::access_control::v1::Entrance&>(::keyapis::access_control::v1::_Entrance_default_instance_);
}
inline const ::keyapis::access_control::v1::Entrance& GetEntranceListResponse::data() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceListResponse.data)
  return _internal_data();
}
inline ::keyapis::access_control::v1::Entrance* GetEntranceListResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.GetEntranceListResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::access_control::v1::Entrance* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetEntranceListResponse::unsafe_arena_set_allocated_data(::keyapis::access_control::v1::Entrance* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceListResponse.data)
}
inline ::keyapis::access_control::v1::Entrance* GetEntranceListResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::keyapis::access_control::v1::Entrance >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::keyapis::access_control::v1::Entrance* GetEntranceListResponse::mutable_data() {
  ::keyapis::access_control::v1::Entrance* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceListResponse.data)
  return _msg;
}

// .keyapis.access_control.v1.GetEntranceListResponse.Error error = 2;
inline bool GetEntranceListResponse::has_error() const {
  return type_case() == kError;
}
inline bool GetEntranceListResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void GetEntranceListResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void GetEntranceListResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::GetEntranceListResponse_Error* GetEntranceListResponse::release_error() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceListResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::GetEntranceListResponse_Error* temp = _impl_.type_.error_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::GetEntranceListResponse_Error& GetEntranceListResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::keyapis::access_control::v1::GetEntranceListResponse_Error&>(::keyapis::access_control::v1::_GetEntranceListResponse_Error_default_instance_);
}
inline const ::keyapis::access_control::v1::GetEntranceListResponse_Error& GetEntranceListResponse::error() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceListResponse.error)
  return _internal_error();
}
inline ::keyapis::access_control::v1::GetEntranceListResponse_Error* GetEntranceListResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.GetEntranceListResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::GetEntranceListResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetEntranceListResponse::unsafe_arena_set_allocated_error(::keyapis::access_control::v1::GetEntranceListResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceListResponse.error)
}
inline ::keyapis::access_control::v1::GetEntranceListResponse_Error* GetEntranceListResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::keyapis::access_control::v1::GetEntranceListResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::keyapis::access_control::v1::GetEntranceListResponse_Error* GetEntranceListResponse::mutable_error() {
  ::keyapis::access_control::v1::GetEntranceListResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceListResponse.error)
  return _msg;
}

inline bool GetEntranceListResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void GetEntranceListResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline GetEntranceListResponse::TypeCase GetEntranceListResponse::type_case() const {
  return GetEntranceListResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// PutEntranceDeviceAttachRequest

// .keyapis.access_control.v1.EntranceDevice entrance_device = 1 [(.google.api.field_behavior) = REQUIRED];
inline bool PutEntranceDeviceAttachRequest::has_entrance_device() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entrance_device_ != nullptr);
  return value;
}
inline void PutEntranceDeviceAttachRequest::clear_entrance_device() {
  if (_impl_.entrance_device_ != nullptr) _impl_.entrance_device_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::keyapis::access_control::v1::EntranceDevice& PutEntranceDeviceAttachRequest::_internal_entrance_device() const {
  const ::keyapis::access_control::v1::EntranceDevice* p = _impl_.entrance_device_;
  return p != nullptr ? *p : reinterpret_cast<const ::keyapis::access_control::v1::EntranceDevice&>(
      ::keyapis::access_control::v1::_EntranceDevice_default_instance_);
}
inline const ::keyapis::access_control::v1::EntranceDevice& PutEntranceDeviceAttachRequest::entrance_device() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PutEntranceDeviceAttachRequest.entrance_device)
  return _internal_entrance_device();
}
inline void PutEntranceDeviceAttachRequest::unsafe_arena_set_allocated_entrance_device(
    ::keyapis::access_control::v1::EntranceDevice* entrance_device) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entrance_device_);
  }
  _impl_.entrance_device_ = entrance_device;
  if (entrance_device) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PutEntranceDeviceAttachRequest.entrance_device)
}
inline ::keyapis::access_control::v1::EntranceDevice* PutEntranceDeviceAttachRequest::release_entrance_device() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::EntranceDevice* temp = _impl_.entrance_device_;
  _impl_.entrance_device_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::keyapis::access_control::v1::EntranceDevice* PutEntranceDeviceAttachRequest::unsafe_arena_release_entrance_device() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PutEntranceDeviceAttachRequest.entrance_device)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::EntranceDevice* temp = _impl_.entrance_device_;
  _impl_.entrance_device_ = nullptr;
  return temp;
}
inline ::keyapis::access_control::v1::EntranceDevice* PutEntranceDeviceAttachRequest::_internal_mutable_entrance_device() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.entrance_device_ == nullptr) {
    auto* p = CreateMaybeMessage<::keyapis::access_control::v1::EntranceDevice>(GetArenaForAllocation());
    _impl_.entrance_device_ = p;
  }
  return _impl_.entrance_device_;
}
inline ::keyapis::access_control::v1::EntranceDevice* PutEntranceDeviceAttachRequest::mutable_entrance_device() {
  ::keyapis::access_control::v1::EntranceDevice* _msg = _internal_mutable_entrance_device();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PutEntranceDeviceAttachRequest.entrance_device)
  return _msg;
}
inline void PutEntranceDeviceAttachRequest::set_allocated_entrance_device(::keyapis::access_control::v1::EntranceDevice* entrance_device) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.entrance_device_;
  }
  if (entrance_device) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(entrance_device);
    if (message_arena != submessage_arena) {
      entrance_device = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entrance_device, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.entrance_device_ = entrance_device;
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.PutEntranceDeviceAttachRequest.entrance_device)
}

// -------------------------------------------------------------------

// PutEntranceDeviceAttachResponse_Error

// .keyapis.access_control.v1.ValidationError validation = 1;
inline bool PutEntranceDeviceAttachResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool PutEntranceDeviceAttachResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void PutEntranceDeviceAttachResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::keyapis::access_control::v1::ValidationError* PutEntranceDeviceAttachResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::ValidationError& PutEntranceDeviceAttachResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::keyapis::access_control::v1::ValidationError&>(::keyapis::access_control::v1::_ValidationError_default_instance_);
}
inline const ::keyapis::access_control::v1::ValidationError& PutEntranceDeviceAttachResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error.validation)
  return _internal_validation();
}
inline ::keyapis::access_control::v1::ValidationError* PutEntranceDeviceAttachResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PutEntranceDeviceAttachResponse_Error::unsafe_arena_set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error.validation)
}
inline ::keyapis::access_control::v1::ValidationError* PutEntranceDeviceAttachResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::keyapis::access_control::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::keyapis::access_control::v1::ValidationError* PutEntranceDeviceAttachResponse_Error::mutable_validation() {
  ::keyapis::access_control::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error.validation)
  return _msg;
}

inline bool PutEntranceDeviceAttachResponse_Error::has_reason() const {
  return reason_case() != REASON_NOT_SET;
}
inline void PutEntranceDeviceAttachResponse_Error::clear_has_reason() {
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}
inline PutEntranceDeviceAttachResponse_Error::ReasonCase PutEntranceDeviceAttachResponse_Error::reason_case() const {
  return PutEntranceDeviceAttachResponse_Error::ReasonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// PutEntranceDeviceAttachResponse

// .keyapis.access_control.v1.PutEntranceDeviceAttachResponse.Error error = 1;
inline bool PutEntranceDeviceAttachResponse::has_error() const {
  return type_case() == kError;
}
inline bool PutEntranceDeviceAttachResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void PutEntranceDeviceAttachResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void PutEntranceDeviceAttachResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* PutEntranceDeviceAttachResponse::release_error() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* temp = _impl_.type_.error_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error& PutEntranceDeviceAttachResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error&>(::keyapis::access_control::v1::_PutEntranceDeviceAttachResponse_Error_default_instance_);
}
inline const ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error& PutEntranceDeviceAttachResponse::error() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.error)
  return _internal_error();
}
inline ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* PutEntranceDeviceAttachResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PutEntranceDeviceAttachResponse::unsafe_arena_set_allocated_error(::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.error)
}
inline ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* PutEntranceDeviceAttachResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* PutEntranceDeviceAttachResponse::mutable_error() {
  ::keyapis::access_control::v1::PutEntranceDeviceAttachResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PutEntranceDeviceAttachResponse.error)
  return _msg;
}

inline bool PutEntranceDeviceAttachResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void PutEntranceDeviceAttachResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline PutEntranceDeviceAttachResponse::TypeCase PutEntranceDeviceAttachResponse::type_case() const {
  return PutEntranceDeviceAttachResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// PutEntranceDeviceDetachRequest

// .keyapis.access_control.v1.EntranceDevice entrance_device = 1 [(.google.api.field_behavior) = REQUIRED];
inline bool PutEntranceDeviceDetachRequest::has_entrance_device() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entrance_device_ != nullptr);
  return value;
}
inline void PutEntranceDeviceDetachRequest::clear_entrance_device() {
  if (_impl_.entrance_device_ != nullptr) _impl_.entrance_device_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::keyapis::access_control::v1::EntranceDevice& PutEntranceDeviceDetachRequest::_internal_entrance_device() const {
  const ::keyapis::access_control::v1::EntranceDevice* p = _impl_.entrance_device_;
  return p != nullptr ? *p : reinterpret_cast<const ::keyapis::access_control::v1::EntranceDevice&>(
      ::keyapis::access_control::v1::_EntranceDevice_default_instance_);
}
inline const ::keyapis::access_control::v1::EntranceDevice& PutEntranceDeviceDetachRequest::entrance_device() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PutEntranceDeviceDetachRequest.entrance_device)
  return _internal_entrance_device();
}
inline void PutEntranceDeviceDetachRequest::unsafe_arena_set_allocated_entrance_device(
    ::keyapis::access_control::v1::EntranceDevice* entrance_device) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entrance_device_);
  }
  _impl_.entrance_device_ = entrance_device;
  if (entrance_device) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PutEntranceDeviceDetachRequest.entrance_device)
}
inline ::keyapis::access_control::v1::EntranceDevice* PutEntranceDeviceDetachRequest::release_entrance_device() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::EntranceDevice* temp = _impl_.entrance_device_;
  _impl_.entrance_device_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::keyapis::access_control::v1::EntranceDevice* PutEntranceDeviceDetachRequest::unsafe_arena_release_entrance_device() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PutEntranceDeviceDetachRequest.entrance_device)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::EntranceDevice* temp = _impl_.entrance_device_;
  _impl_.entrance_device_ = nullptr;
  return temp;
}
inline ::keyapis::access_control::v1::EntranceDevice* PutEntranceDeviceDetachRequest::_internal_mutable_entrance_device() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.entrance_device_ == nullptr) {
    auto* p = CreateMaybeMessage<::keyapis::access_control::v1::EntranceDevice>(GetArenaForAllocation());
    _impl_.entrance_device_ = p;
  }
  return _impl_.entrance_device_;
}
inline ::keyapis::access_control::v1::EntranceDevice* PutEntranceDeviceDetachRequest::mutable_entrance_device() {
  ::keyapis::access_control::v1::EntranceDevice* _msg = _internal_mutable_entrance_device();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PutEntranceDeviceDetachRequest.entrance_device)
  return _msg;
}
inline void PutEntranceDeviceDetachRequest::set_allocated_entrance_device(::keyapis::access_control::v1::EntranceDevice* entrance_device) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.entrance_device_;
  }
  if (entrance_device) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(entrance_device);
    if (message_arena != submessage_arena) {
      entrance_device = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entrance_device, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.entrance_device_ = entrance_device;
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.PutEntranceDeviceDetachRequest.entrance_device)
}

// -------------------------------------------------------------------

// PutEntranceDeviceDetachResponse_Error

// .keyapis.access_control.v1.ValidationError validation = 1;
inline bool PutEntranceDeviceDetachResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool PutEntranceDeviceDetachResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void PutEntranceDeviceDetachResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::keyapis::access_control::v1::ValidationError* PutEntranceDeviceDetachResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::ValidationError& PutEntranceDeviceDetachResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::keyapis::access_control::v1::ValidationError&>(::keyapis::access_control::v1::_ValidationError_default_instance_);
}
inline const ::keyapis::access_control::v1::ValidationError& PutEntranceDeviceDetachResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error.validation)
  return _internal_validation();
}
inline ::keyapis::access_control::v1::ValidationError* PutEntranceDeviceDetachResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PutEntranceDeviceDetachResponse_Error::unsafe_arena_set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error.validation)
}
inline ::keyapis::access_control::v1::ValidationError* PutEntranceDeviceDetachResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::keyapis::access_control::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::keyapis::access_control::v1::ValidationError* PutEntranceDeviceDetachResponse_Error::mutable_validation() {
  ::keyapis::access_control::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error.validation)
  return _msg;
}

inline bool PutEntranceDeviceDetachResponse_Error::has_reason() const {
  return reason_case() != REASON_NOT_SET;
}
inline void PutEntranceDeviceDetachResponse_Error::clear_has_reason() {
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}
inline PutEntranceDeviceDetachResponse_Error::ReasonCase PutEntranceDeviceDetachResponse_Error::reason_case() const {
  return PutEntranceDeviceDetachResponse_Error::ReasonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// PutEntranceDeviceDetachResponse

// .keyapis.access_control.v1.PutEntranceDeviceDetachResponse.Error error = 1;
inline bool PutEntranceDeviceDetachResponse::has_error() const {
  return type_case() == kError;
}
inline bool PutEntranceDeviceDetachResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void PutEntranceDeviceDetachResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void PutEntranceDeviceDetachResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* PutEntranceDeviceDetachResponse::release_error() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* temp = _impl_.type_.error_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error& PutEntranceDeviceDetachResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error&>(::keyapis::access_control::v1::_PutEntranceDeviceDetachResponse_Error_default_instance_);
}
inline const ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error& PutEntranceDeviceDetachResponse::error() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.error)
  return _internal_error();
}
inline ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* PutEntranceDeviceDetachResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PutEntranceDeviceDetachResponse::unsafe_arena_set_allocated_error(::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.error)
}
inline ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* PutEntranceDeviceDetachResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* PutEntranceDeviceDetachResponse::mutable_error() {
  ::keyapis::access_control::v1::PutEntranceDeviceDetachResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PutEntranceDeviceDetachResponse.error)
  return _msg;
}

inline bool PutEntranceDeviceDetachResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void PutEntranceDeviceDetachResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline PutEntranceDeviceDetachResponse::TypeCase PutEntranceDeviceDetachResponse::type_case() const {
  return PutEntranceDeviceDetachResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// PostEntranceRequest

// .keyapis.access_control.v1.Entrance data = 1 [(.google.api.field_behavior) = REQUIRED];
inline bool PostEntranceRequest::has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr);
  return value;
}
inline void PostEntranceRequest::clear_data() {
  if (_impl_.data_ != nullptr) _impl_.data_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::keyapis::access_control::v1::Entrance& PostEntranceRequest::_internal_data() const {
  const ::keyapis::access_control::v1::Entrance* p = _impl_.data_;
  return p != nullptr ? *p : reinterpret_cast<const ::keyapis::access_control::v1::Entrance&>(
      ::keyapis::access_control::v1::_Entrance_default_instance_);
}
inline const ::keyapis::access_control::v1::Entrance& PostEntranceRequest::data() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PostEntranceRequest.data)
  return _internal_data();
}
inline void PostEntranceRequest::unsafe_arena_set_allocated_data(
    ::keyapis::access_control::v1::Entrance* data) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.data_);
  }
  _impl_.data_ = data;
  if (data) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PostEntranceRequest.data)
}
inline ::keyapis::access_control::v1::Entrance* PostEntranceRequest::release_data() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::Entrance* temp = _impl_.data_;
  _impl_.data_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::keyapis::access_control::v1::Entrance* PostEntranceRequest::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PostEntranceRequest.data)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::Entrance* temp = _impl_.data_;
  _impl_.data_ = nullptr;
  return temp;
}
inline ::keyapis::access_control::v1::Entrance* PostEntranceRequest::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.data_ == nullptr) {
    auto* p = CreateMaybeMessage<::keyapis::access_control::v1::Entrance>(GetArenaForAllocation());
    _impl_.data_ = p;
  }
  return _impl_.data_;
}
inline ::keyapis::access_control::v1::Entrance* PostEntranceRequest::mutable_data() {
  ::keyapis::access_control::v1::Entrance* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PostEntranceRequest.data)
  return _msg;
}
inline void PostEntranceRequest::set_allocated_data(::keyapis::access_control::v1::Entrance* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.data_;
  }
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_ = data;
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.PostEntranceRequest.data)
}

// -------------------------------------------------------------------

// PostEntranceResponse_Error

// .keyapis.access_control.v1.ValidationError validation = 1;
inline bool PostEntranceResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool PostEntranceResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void PostEntranceResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::keyapis::access_control::v1::ValidationError* PostEntranceResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PostEntranceResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::ValidationError& PostEntranceResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::keyapis::access_control::v1::ValidationError&>(::keyapis::access_control::v1::_ValidationError_default_instance_);
}
inline const ::keyapis::access_control::v1::ValidationError& PostEntranceResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PostEntranceResponse.Error.validation)
  return _internal_validation();
}
inline ::keyapis::access_control::v1::ValidationError* PostEntranceResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.PostEntranceResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PostEntranceResponse_Error::unsafe_arena_set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PostEntranceResponse.Error.validation)
}
inline ::keyapis::access_control::v1::ValidationError* PostEntranceResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::keyapis::access_control::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::keyapis::access_control::v1::ValidationError* PostEntranceResponse_Error::mutable_validation() {
  ::keyapis::access_control::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PostEntranceResponse.Error.validation)
  return _msg;
}

inline bool PostEntranceResponse_Error::has_reason() const {
  return reason_case() != REASON_NOT_SET;
}
inline void PostEntranceResponse_Error::clear_has_reason() {
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}
inline PostEntranceResponse_Error::ReasonCase PostEntranceResponse_Error::reason_case() const {
  return PostEntranceResponse_Error::ReasonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// PostEntranceResponse

// .keyapis.access_control.v1.Entrance data = 1;
inline bool PostEntranceResponse::has_data() const {
  return type_case() == kData;
}
inline bool PostEntranceResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void PostEntranceResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void PostEntranceResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::Entrance* PostEntranceResponse::release_data() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PostEntranceResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::access_control::v1::Entrance* temp = _impl_.type_.data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::Entrance& PostEntranceResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::keyapis::access_control::v1::Entrance&>(::keyapis::access_control::v1::_Entrance_default_instance_);
}
inline const ::keyapis::access_control::v1::Entrance& PostEntranceResponse::data() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PostEntranceResponse.data)
  return _internal_data();
}
inline ::keyapis::access_control::v1::Entrance* PostEntranceResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.PostEntranceResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::access_control::v1::Entrance* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PostEntranceResponse::unsafe_arena_set_allocated_data(::keyapis::access_control::v1::Entrance* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PostEntranceResponse.data)
}
inline ::keyapis::access_control::v1::Entrance* PostEntranceResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::keyapis::access_control::v1::Entrance >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::keyapis::access_control::v1::Entrance* PostEntranceResponse::mutable_data() {
  ::keyapis::access_control::v1::Entrance* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PostEntranceResponse.data)
  return _msg;
}

// .keyapis.access_control.v1.PostEntranceResponse.Error error = 2;
inline bool PostEntranceResponse::has_error() const {
  return type_case() == kError;
}
inline bool PostEntranceResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void PostEntranceResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void PostEntranceResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::PostEntranceResponse_Error* PostEntranceResponse::release_error() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.PostEntranceResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::PostEntranceResponse_Error* temp = _impl_.type_.error_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::PostEntranceResponse_Error& PostEntranceResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::keyapis::access_control::v1::PostEntranceResponse_Error&>(::keyapis::access_control::v1::_PostEntranceResponse_Error_default_instance_);
}
inline const ::keyapis::access_control::v1::PostEntranceResponse_Error& PostEntranceResponse::error() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.PostEntranceResponse.error)
  return _internal_error();
}
inline ::keyapis::access_control::v1::PostEntranceResponse_Error* PostEntranceResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.PostEntranceResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::PostEntranceResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PostEntranceResponse::unsafe_arena_set_allocated_error(::keyapis::access_control::v1::PostEntranceResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.PostEntranceResponse.error)
}
inline ::keyapis::access_control::v1::PostEntranceResponse_Error* PostEntranceResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::keyapis::access_control::v1::PostEntranceResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::keyapis::access_control::v1::PostEntranceResponse_Error* PostEntranceResponse::mutable_error() {
  ::keyapis::access_control::v1::PostEntranceResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.PostEntranceResponse.error)
  return _msg;
}

inline bool PostEntranceResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void PostEntranceResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline PostEntranceResponse::TypeCase PostEntranceResponse::type_case() const {
  return PostEntranceResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// DeleteEntranceRequest

// int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
inline void DeleteEntranceRequest::clear_orpon() {
  _impl_.orpon_ = ::int64_t{0};
}
inline ::int64_t DeleteEntranceRequest::orpon() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.DeleteEntranceRequest.orpon)
  return _internal_orpon();
}
inline void DeleteEntranceRequest::set_orpon(::int64_t value) {
  _internal_set_orpon(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.DeleteEntranceRequest.orpon)
}
inline ::int64_t DeleteEntranceRequest::_internal_orpon() const {
  return _impl_.orpon_;
}
inline void DeleteEntranceRequest::_internal_set_orpon(::int64_t value) {
  ;
  _impl_.orpon_ = value;
}

// int32 entrance_number = 2 [(.google.api.field_behavior) = REQUIRED];
inline void DeleteEntranceRequest::clear_entrance_number() {
  _impl_.entrance_number_ = 0;
}
inline ::int32_t DeleteEntranceRequest::entrance_number() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.DeleteEntranceRequest.entrance_number)
  return _internal_entrance_number();
}
inline void DeleteEntranceRequest::set_entrance_number(::int32_t value) {
  _internal_set_entrance_number(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.DeleteEntranceRequest.entrance_number)
}
inline ::int32_t DeleteEntranceRequest::_internal_entrance_number() const {
  return _impl_.entrance_number_;
}
inline void DeleteEntranceRequest::_internal_set_entrance_number(::int32_t value) {
  ;
  _impl_.entrance_number_ = value;
}

// -------------------------------------------------------------------

// DeleteEntranceResponse_Error_LinkedDevicesExists

// -------------------------------------------------------------------

// DeleteEntranceResponse_Error

// .keyapis.access_control.v1.ValidationError validation = 1;
inline bool DeleteEntranceResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool DeleteEntranceResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void DeleteEntranceResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::keyapis::access_control::v1::ValidationError* DeleteEntranceResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.DeleteEntranceResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::ValidationError& DeleteEntranceResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::keyapis::access_control::v1::ValidationError&>(::keyapis::access_control::v1::_ValidationError_default_instance_);
}
inline const ::keyapis::access_control::v1::ValidationError& DeleteEntranceResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.DeleteEntranceResponse.Error.validation)
  return _internal_validation();
}
inline ::keyapis::access_control::v1::ValidationError* DeleteEntranceResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.DeleteEntranceResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DeleteEntranceResponse_Error::unsafe_arena_set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.DeleteEntranceResponse.Error.validation)
}
inline ::keyapis::access_control::v1::ValidationError* DeleteEntranceResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::keyapis::access_control::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::keyapis::access_control::v1::ValidationError* DeleteEntranceResponse_Error::mutable_validation() {
  ::keyapis::access_control::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.DeleteEntranceResponse.Error.validation)
  return _msg;
}

// .keyapis.access_control.v1.DeleteEntranceResponse.Error.LinkedDevicesExists linked_devices_exists = 2;
inline bool DeleteEntranceResponse_Error::has_linked_devices_exists() const {
  return reason_case() == kLinkedDevicesExists;
}
inline bool DeleteEntranceResponse_Error::_internal_has_linked_devices_exists() const {
  return reason_case() == kLinkedDevicesExists;
}
inline void DeleteEntranceResponse_Error::set_has_linked_devices_exists() {
  _impl_._oneof_case_[0] = kLinkedDevicesExists;
}
inline void DeleteEntranceResponse_Error::clear_linked_devices_exists() {
  if (reason_case() == kLinkedDevicesExists) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.linked_devices_exists_;
    }
    clear_has_reason();
  }
}
inline ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* DeleteEntranceResponse_Error::release_linked_devices_exists() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.DeleteEntranceResponse.Error.linked_devices_exists)
  if (reason_case() == kLinkedDevicesExists) {
    clear_has_reason();
    ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* temp = _impl_.reason_.linked_devices_exists_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.linked_devices_exists_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists& DeleteEntranceResponse_Error::_internal_linked_devices_exists() const {
  return reason_case() == kLinkedDevicesExists
      ? *_impl_.reason_.linked_devices_exists_
      : reinterpret_cast<::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists&>(::keyapis::access_control::v1::_DeleteEntranceResponse_Error_LinkedDevicesExists_default_instance_);
}
inline const ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists& DeleteEntranceResponse_Error::linked_devices_exists() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.DeleteEntranceResponse.Error.linked_devices_exists)
  return _internal_linked_devices_exists();
}
inline ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* DeleteEntranceResponse_Error::unsafe_arena_release_linked_devices_exists() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.DeleteEntranceResponse.Error.linked_devices_exists)
  if (reason_case() == kLinkedDevicesExists) {
    clear_has_reason();
    ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* temp = _impl_.reason_.linked_devices_exists_;
    _impl_.reason_.linked_devices_exists_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DeleteEntranceResponse_Error::unsafe_arena_set_allocated_linked_devices_exists(::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* linked_devices_exists) {
  clear_reason();
  if (linked_devices_exists) {
    set_has_linked_devices_exists();
    _impl_.reason_.linked_devices_exists_ = linked_devices_exists;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.DeleteEntranceResponse.Error.linked_devices_exists)
}
inline ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* DeleteEntranceResponse_Error::_internal_mutable_linked_devices_exists() {
  if (reason_case() != kLinkedDevicesExists) {
    clear_reason();
    set_has_linked_devices_exists();
    _impl_.reason_.linked_devices_exists_ = CreateMaybeMessage< ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists >(GetArenaForAllocation());
  }
  return _impl_.reason_.linked_devices_exists_;
}
inline ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* DeleteEntranceResponse_Error::mutable_linked_devices_exists() {
  ::keyapis::access_control::v1::DeleteEntranceResponse_Error_LinkedDevicesExists* _msg = _internal_mutable_linked_devices_exists();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.DeleteEntranceResponse.Error.linked_devices_exists)
  return _msg;
}

inline bool DeleteEntranceResponse_Error::has_reason() const {
  return reason_case() != REASON_NOT_SET;
}
inline void DeleteEntranceResponse_Error::clear_has_reason() {
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}
inline DeleteEntranceResponse_Error::ReasonCase DeleteEntranceResponse_Error::reason_case() const {
  return DeleteEntranceResponse_Error::ReasonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// DeleteEntranceResponse

// .keyapis.access_control.v1.DeleteEntranceResponse.Error error = 1;
inline bool DeleteEntranceResponse::has_error() const {
  return type_case() == kError;
}
inline bool DeleteEntranceResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void DeleteEntranceResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void DeleteEntranceResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::DeleteEntranceResponse_Error* DeleteEntranceResponse::release_error() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.DeleteEntranceResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::DeleteEntranceResponse_Error* temp = _impl_.type_.error_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::DeleteEntranceResponse_Error& DeleteEntranceResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::keyapis::access_control::v1::DeleteEntranceResponse_Error&>(::keyapis::access_control::v1::_DeleteEntranceResponse_Error_default_instance_);
}
inline const ::keyapis::access_control::v1::DeleteEntranceResponse_Error& DeleteEntranceResponse::error() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.DeleteEntranceResponse.error)
  return _internal_error();
}
inline ::keyapis::access_control::v1::DeleteEntranceResponse_Error* DeleteEntranceResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.DeleteEntranceResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::DeleteEntranceResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DeleteEntranceResponse::unsafe_arena_set_allocated_error(::keyapis::access_control::v1::DeleteEntranceResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.DeleteEntranceResponse.error)
}
inline ::keyapis::access_control::v1::DeleteEntranceResponse_Error* DeleteEntranceResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::keyapis::access_control::v1::DeleteEntranceResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::keyapis::access_control::v1::DeleteEntranceResponse_Error* DeleteEntranceResponse::mutable_error() {
  ::keyapis::access_control::v1::DeleteEntranceResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.DeleteEntranceResponse.error)
  return _msg;
}

inline bool DeleteEntranceResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void DeleteEntranceResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline DeleteEntranceResponse::TypeCase DeleteEntranceResponse::type_case() const {
  return DeleteEntranceResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// EntranceDevice

// int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
inline void EntranceDevice::clear_orpon() {
  _impl_.orpon_ = ::int64_t{0};
}
inline ::int64_t EntranceDevice::orpon() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDevice.orpon)
  return _internal_orpon();
}
inline void EntranceDevice::set_orpon(::int64_t value) {
  _internal_set_orpon(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDevice.orpon)
}
inline ::int64_t EntranceDevice::_internal_orpon() const {
  return _impl_.orpon_;
}
inline void EntranceDevice::_internal_set_orpon(::int64_t value) {
  ;
  _impl_.orpon_ = value;
}

// int32 entrance_number = 2 [(.google.api.field_behavior) = REQUIRED];
inline void EntranceDevice::clear_entrance_number() {
  _impl_.entrance_number_ = 0;
}
inline ::int32_t EntranceDevice::entrance_number() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDevice.entrance_number)
  return _internal_entrance_number();
}
inline void EntranceDevice::set_entrance_number(::int32_t value) {
  _internal_set_entrance_number(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDevice.entrance_number)
}
inline ::int32_t EntranceDevice::_internal_entrance_number() const {
  return _impl_.entrance_number_;
}
inline void EntranceDevice::_internal_set_entrance_number(::int32_t value) {
  ;
  _impl_.entrance_number_ = value;
}

// int32 device_id = 3 [(.google.api.field_behavior) = REQUIRED];
inline void EntranceDevice::clear_device_id() {
  _impl_.device_id_ = 0;
}
inline ::int32_t EntranceDevice::device_id() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDevice.device_id)
  return _internal_device_id();
}
inline void EntranceDevice::set_device_id(::int32_t value) {
  _internal_set_device_id(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDevice.device_id)
}
inline ::int32_t EntranceDevice::_internal_device_id() const {
  return _impl_.device_id_;
}
inline void EntranceDevice::_internal_set_device_id(::int32_t value) {
  ;
  _impl_.device_id_ = value;
}

// .keyapis.access_control.v1.EntranceDevice.RelationType relation_type = 4 [(.google.api.field_behavior) = OUTPUT_ONLY];
inline void EntranceDevice::clear_relation_type() {
  _impl_.relation_type_ = 0;
}
inline ::keyapis::access_control::v1::EntranceDevice_RelationType EntranceDevice::relation_type() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDevice.relation_type)
  return _internal_relation_type();
}
inline void EntranceDevice::set_relation_type(::keyapis::access_control::v1::EntranceDevice_RelationType value) {
   _internal_set_relation_type(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDevice.relation_type)
}
inline ::keyapis::access_control::v1::EntranceDevice_RelationType EntranceDevice::_internal_relation_type() const {
  return static_cast<::keyapis::access_control::v1::EntranceDevice_RelationType>(_impl_.relation_type_);
}
inline void EntranceDevice::_internal_set_relation_type(::keyapis::access_control::v1::EntranceDevice_RelationType value) {
  ;
  _impl_.relation_type_ = value;
}

// -------------------------------------------------------------------

// EntranceDeviceFilter

// repeated int32 flatgramm_ids = 1;
inline int EntranceDeviceFilter::_internal_flatgramm_ids_size() const {
  return _impl_.flatgramm_ids_.size();
}
inline int EntranceDeviceFilter::flatgramm_ids_size() const {
  return _internal_flatgramm_ids_size();
}
inline void EntranceDeviceFilter::clear_flatgramm_ids() {
  _internal_mutable_flatgramm_ids()->Clear();
}
inline ::int32_t EntranceDeviceFilter::flatgramm_ids(int index) const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDeviceFilter.flatgramm_ids)
  return _internal_flatgramm_ids(index);
}
inline void EntranceDeviceFilter::set_flatgramm_ids(int index, ::int32_t value) {
  _internal_mutable_flatgramm_ids()->Set(index, value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDeviceFilter.flatgramm_ids)
}
inline void EntranceDeviceFilter::add_flatgramm_ids(::int32_t value) {
  _internal_add_flatgramm_ids(value);
  // @@protoc_insertion_point(field_add:keyapis.access_control.v1.EntranceDeviceFilter.flatgramm_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceDeviceFilter::flatgramm_ids() const {
  // @@protoc_insertion_point(field_list:keyapis.access_control.v1.EntranceDeviceFilter.flatgramm_ids)
  return _internal_flatgramm_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceDeviceFilter::mutable_flatgramm_ids() {
  // @@protoc_insertion_point(field_mutable_list:keyapis.access_control.v1.EntranceDeviceFilter.flatgramm_ids)
  return _internal_mutable_flatgramm_ids();
}

inline ::int32_t EntranceDeviceFilter::_internal_flatgramm_ids(int index) const {
  return _internal_flatgramm_ids().Get(index);
}
inline void EntranceDeviceFilter::_internal_add_flatgramm_ids(::int32_t value) {
  _internal_mutable_flatgramm_ids()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceDeviceFilter::_internal_flatgramm_ids() const {
  return _impl_.flatgramm_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceDeviceFilter::_internal_mutable_flatgramm_ids() {
  return &_impl_.flatgramm_ids_;
}

// repeated int64 orpons = 2;
inline int EntranceDeviceFilter::_internal_orpons_size() const {
  return _impl_.orpons_.size();
}
inline int EntranceDeviceFilter::orpons_size() const {
  return _internal_orpons_size();
}
inline void EntranceDeviceFilter::clear_orpons() {
  _internal_mutable_orpons()->Clear();
}
inline ::int64_t EntranceDeviceFilter::orpons(int index) const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDeviceFilter.orpons)
  return _internal_orpons(index);
}
inline void EntranceDeviceFilter::set_orpons(int index, ::int64_t value) {
  _internal_mutable_orpons()->Set(index, value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDeviceFilter.orpons)
}
inline void EntranceDeviceFilter::add_orpons(::int64_t value) {
  _internal_add_orpons(value);
  // @@protoc_insertion_point(field_add:keyapis.access_control.v1.EntranceDeviceFilter.orpons)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>& EntranceDeviceFilter::orpons() const {
  // @@protoc_insertion_point(field_list:keyapis.access_control.v1.EntranceDeviceFilter.orpons)
  return _internal_orpons();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>* EntranceDeviceFilter::mutable_orpons() {
  // @@protoc_insertion_point(field_mutable_list:keyapis.access_control.v1.EntranceDeviceFilter.orpons)
  return _internal_mutable_orpons();
}

inline ::int64_t EntranceDeviceFilter::_internal_orpons(int index) const {
  return _internal_orpons().Get(index);
}
inline void EntranceDeviceFilter::_internal_add_orpons(::int64_t value) {
  _internal_mutable_orpons()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>& EntranceDeviceFilter::_internal_orpons() const {
  return _impl_.orpons_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int64_t>* EntranceDeviceFilter::_internal_mutable_orpons() {
  return &_impl_.orpons_;
}

// repeated int32 entrance_numbers = 3;
inline int EntranceDeviceFilter::_internal_entrance_numbers_size() const {
  return _impl_.entrance_numbers_.size();
}
inline int EntranceDeviceFilter::entrance_numbers_size() const {
  return _internal_entrance_numbers_size();
}
inline void EntranceDeviceFilter::clear_entrance_numbers() {
  _internal_mutable_entrance_numbers()->Clear();
}
inline ::int32_t EntranceDeviceFilter::entrance_numbers(int index) const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDeviceFilter.entrance_numbers)
  return _internal_entrance_numbers(index);
}
inline void EntranceDeviceFilter::set_entrance_numbers(int index, ::int32_t value) {
  _internal_mutable_entrance_numbers()->Set(index, value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDeviceFilter.entrance_numbers)
}
inline void EntranceDeviceFilter::add_entrance_numbers(::int32_t value) {
  _internal_add_entrance_numbers(value);
  // @@protoc_insertion_point(field_add:keyapis.access_control.v1.EntranceDeviceFilter.entrance_numbers)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceDeviceFilter::entrance_numbers() const {
  // @@protoc_insertion_point(field_list:keyapis.access_control.v1.EntranceDeviceFilter.entrance_numbers)
  return _internal_entrance_numbers();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceDeviceFilter::mutable_entrance_numbers() {
  // @@protoc_insertion_point(field_mutable_list:keyapis.access_control.v1.EntranceDeviceFilter.entrance_numbers)
  return _internal_mutable_entrance_numbers();
}

inline ::int32_t EntranceDeviceFilter::_internal_entrance_numbers(int index) const {
  return _internal_entrance_numbers().Get(index);
}
inline void EntranceDeviceFilter::_internal_add_entrance_numbers(::int32_t value) {
  _internal_mutable_entrance_numbers()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceDeviceFilter::_internal_entrance_numbers() const {
  return _impl_.entrance_numbers_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceDeviceFilter::_internal_mutable_entrance_numbers() {
  return &_impl_.entrance_numbers_;
}

// repeated int32 device_ids = 4;
inline int EntranceDeviceFilter::_internal_device_ids_size() const {
  return _impl_.device_ids_.size();
}
inline int EntranceDeviceFilter::device_ids_size() const {
  return _internal_device_ids_size();
}
inline void EntranceDeviceFilter::clear_device_ids() {
  _internal_mutable_device_ids()->Clear();
}
inline ::int32_t EntranceDeviceFilter::device_ids(int index) const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDeviceFilter.device_ids)
  return _internal_device_ids(index);
}
inline void EntranceDeviceFilter::set_device_ids(int index, ::int32_t value) {
  _internal_mutable_device_ids()->Set(index, value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDeviceFilter.device_ids)
}
inline void EntranceDeviceFilter::add_device_ids(::int32_t value) {
  _internal_add_device_ids(value);
  // @@protoc_insertion_point(field_add:keyapis.access_control.v1.EntranceDeviceFilter.device_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceDeviceFilter::device_ids() const {
  // @@protoc_insertion_point(field_list:keyapis.access_control.v1.EntranceDeviceFilter.device_ids)
  return _internal_device_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceDeviceFilter::mutable_device_ids() {
  // @@protoc_insertion_point(field_mutable_list:keyapis.access_control.v1.EntranceDeviceFilter.device_ids)
  return _internal_mutable_device_ids();
}

inline ::int32_t EntranceDeviceFilter::_internal_device_ids(int index) const {
  return _internal_device_ids().Get(index);
}
inline void EntranceDeviceFilter::_internal_add_device_ids(::int32_t value) {
  _internal_mutable_device_ids()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& EntranceDeviceFilter::_internal_device_ids() const {
  return _impl_.device_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* EntranceDeviceFilter::_internal_mutable_device_ids() {
  return &_impl_.device_ids_;
}

// -------------------------------------------------------------------

// EntranceDevicePaging

// .keyapis.access_control.v1.EntranceDevicePaging.OrderByType order_by_type = 1;
inline void EntranceDevicePaging::clear_order_by_type() {
  _impl_.order_by_type_ = 0;
}
inline ::keyapis::access_control::v1::EntranceDevicePaging_OrderByType EntranceDevicePaging::order_by_type() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDevicePaging.order_by_type)
  return _internal_order_by_type();
}
inline void EntranceDevicePaging::set_order_by_type(::keyapis::access_control::v1::EntranceDevicePaging_OrderByType value) {
   _internal_set_order_by_type(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDevicePaging.order_by_type)
}
inline ::keyapis::access_control::v1::EntranceDevicePaging_OrderByType EntranceDevicePaging::_internal_order_by_type() const {
  return static_cast<::keyapis::access_control::v1::EntranceDevicePaging_OrderByType>(_impl_.order_by_type_);
}
inline void EntranceDevicePaging::_internal_set_order_by_type(::keyapis::access_control::v1::EntranceDevicePaging_OrderByType value) {
  ;
  _impl_.order_by_type_ = value;
}

// .keyapis.access_control.v1.EntranceDevicePaging.DirectionType direction_type = 2;
inline void EntranceDevicePaging::clear_direction_type() {
  _impl_.direction_type_ = 0;
}
inline ::keyapis::access_control::v1::EntranceDevicePaging_DirectionType EntranceDevicePaging::direction_type() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDevicePaging.direction_type)
  return _internal_direction_type();
}
inline void EntranceDevicePaging::set_direction_type(::keyapis::access_control::v1::EntranceDevicePaging_DirectionType value) {
   _internal_set_direction_type(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDevicePaging.direction_type)
}
inline ::keyapis::access_control::v1::EntranceDevicePaging_DirectionType EntranceDevicePaging::_internal_direction_type() const {
  return static_cast<::keyapis::access_control::v1::EntranceDevicePaging_DirectionType>(_impl_.direction_type_);
}
inline void EntranceDevicePaging::_internal_set_direction_type(::keyapis::access_control::v1::EntranceDevicePaging_DirectionType value) {
  ;
  _impl_.direction_type_ = value;
}

// int32 limit = 3;
inline void EntranceDevicePaging::clear_limit() {
  _impl_.limit_ = 0;
}
inline ::int32_t EntranceDevicePaging::limit() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDevicePaging.limit)
  return _internal_limit();
}
inline void EntranceDevicePaging::set_limit(::int32_t value) {
  _internal_set_limit(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDevicePaging.limit)
}
inline ::int32_t EntranceDevicePaging::_internal_limit() const {
  return _impl_.limit_;
}
inline void EntranceDevicePaging::_internal_set_limit(::int32_t value) {
  ;
  _impl_.limit_ = value;
}

// int32 offset = 4;
inline void EntranceDevicePaging::clear_offset() {
  _impl_.offset_ = 0;
}
inline ::int32_t EntranceDevicePaging::offset() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.EntranceDevicePaging.offset)
  return _internal_offset();
}
inline void EntranceDevicePaging::set_offset(::int32_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:keyapis.access_control.v1.EntranceDevicePaging.offset)
}
inline ::int32_t EntranceDevicePaging::_internal_offset() const {
  return _impl_.offset_;
}
inline void EntranceDevicePaging::_internal_set_offset(::int32_t value) {
  ;
  _impl_.offset_ = value;
}

// -------------------------------------------------------------------

// GetEntranceDeviceListRequest

// .keyapis.access_control.v1.EntranceDeviceFilter filter = 1;
inline bool GetEntranceDeviceListRequest::has_filter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.filter_ != nullptr);
  return value;
}
inline void GetEntranceDeviceListRequest::clear_filter() {
  if (_impl_.filter_ != nullptr) _impl_.filter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::keyapis::access_control::v1::EntranceDeviceFilter& GetEntranceDeviceListRequest::_internal_filter() const {
  const ::keyapis::access_control::v1::EntranceDeviceFilter* p = _impl_.filter_;
  return p != nullptr ? *p : reinterpret_cast<const ::keyapis::access_control::v1::EntranceDeviceFilter&>(
      ::keyapis::access_control::v1::_EntranceDeviceFilter_default_instance_);
}
inline const ::keyapis::access_control::v1::EntranceDeviceFilter& GetEntranceDeviceListRequest::filter() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceDeviceListRequest.filter)
  return _internal_filter();
}
inline void GetEntranceDeviceListRequest::unsafe_arena_set_allocated_filter(
    ::keyapis::access_control::v1::EntranceDeviceFilter* filter) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.filter_);
  }
  _impl_.filter_ = filter;
  if (filter) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceDeviceListRequest.filter)
}
inline ::keyapis::access_control::v1::EntranceDeviceFilter* GetEntranceDeviceListRequest::release_filter() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::EntranceDeviceFilter* temp = _impl_.filter_;
  _impl_.filter_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::keyapis::access_control::v1::EntranceDeviceFilter* GetEntranceDeviceListRequest::unsafe_arena_release_filter() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceDeviceListRequest.filter)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::access_control::v1::EntranceDeviceFilter* temp = _impl_.filter_;
  _impl_.filter_ = nullptr;
  return temp;
}
inline ::keyapis::access_control::v1::EntranceDeviceFilter* GetEntranceDeviceListRequest::_internal_mutable_filter() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.filter_ == nullptr) {
    auto* p = CreateMaybeMessage<::keyapis::access_control::v1::EntranceDeviceFilter>(GetArenaForAllocation());
    _impl_.filter_ = p;
  }
  return _impl_.filter_;
}
inline ::keyapis::access_control::v1::EntranceDeviceFilter* GetEntranceDeviceListRequest::mutable_filter() {
  ::keyapis::access_control::v1::EntranceDeviceFilter* _msg = _internal_mutable_filter();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceDeviceListRequest.filter)
  return _msg;
}
inline void GetEntranceDeviceListRequest::set_allocated_filter(::keyapis::access_control::v1::EntranceDeviceFilter* filter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.filter_;
  }
  if (filter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(filter);
    if (message_arena != submessage_arena) {
      filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filter, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.filter_ = filter;
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.GetEntranceDeviceListRequest.filter)
}

// .keyapis.access_control.v1.EntranceDevicePaging paging = 2;
inline bool GetEntranceDeviceListRequest::has_paging() const {
  return pagination_case() == kPaging;
}
inline bool GetEntranceDeviceListRequest::_internal_has_paging() const {
  return pagination_case() == kPaging;
}
inline void GetEntranceDeviceListRequest::set_has_paging() {
  _impl_._oneof_case_[0] = kPaging;
}
inline void GetEntranceDeviceListRequest::clear_paging() {
  if (pagination_case() == kPaging) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.pagination_.paging_;
    }
    clear_has_pagination();
  }
}
inline ::keyapis::access_control::v1::EntranceDevicePaging* GetEntranceDeviceListRequest::release_paging() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceDeviceListRequest.paging)
  if (pagination_case() == kPaging) {
    clear_has_pagination();
    ::keyapis::access_control::v1::EntranceDevicePaging* temp = _impl_.pagination_.paging_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.pagination_.paging_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::EntranceDevicePaging& GetEntranceDeviceListRequest::_internal_paging() const {
  return pagination_case() == kPaging
      ? *_impl_.pagination_.paging_
      : reinterpret_cast<::keyapis::access_control::v1::EntranceDevicePaging&>(::keyapis::access_control::v1::_EntranceDevicePaging_default_instance_);
}
inline const ::keyapis::access_control::v1::EntranceDevicePaging& GetEntranceDeviceListRequest::paging() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceDeviceListRequest.paging)
  return _internal_paging();
}
inline ::keyapis::access_control::v1::EntranceDevicePaging* GetEntranceDeviceListRequest::unsafe_arena_release_paging() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.GetEntranceDeviceListRequest.paging)
  if (pagination_case() == kPaging) {
    clear_has_pagination();
    ::keyapis::access_control::v1::EntranceDevicePaging* temp = _impl_.pagination_.paging_;
    _impl_.pagination_.paging_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetEntranceDeviceListRequest::unsafe_arena_set_allocated_paging(::keyapis::access_control::v1::EntranceDevicePaging* paging) {
  clear_pagination();
  if (paging) {
    set_has_paging();
    _impl_.pagination_.paging_ = paging;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceDeviceListRequest.paging)
}
inline ::keyapis::access_control::v1::EntranceDevicePaging* GetEntranceDeviceListRequest::_internal_mutable_paging() {
  if (pagination_case() != kPaging) {
    clear_pagination();
    set_has_paging();
    _impl_.pagination_.paging_ = CreateMaybeMessage< ::keyapis::access_control::v1::EntranceDevicePaging >(GetArenaForAllocation());
  }
  return _impl_.pagination_.paging_;
}
inline ::keyapis::access_control::v1::EntranceDevicePaging* GetEntranceDeviceListRequest::mutable_paging() {
  ::keyapis::access_control::v1::EntranceDevicePaging* _msg = _internal_mutable_paging();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceDeviceListRequest.paging)
  return _msg;
}

inline bool GetEntranceDeviceListRequest::has_pagination() const {
  return pagination_case() != PAGINATION_NOT_SET;
}
inline void GetEntranceDeviceListRequest::clear_has_pagination() {
  _impl_._oneof_case_[0] = PAGINATION_NOT_SET;
}
inline GetEntranceDeviceListRequest::PaginationCase GetEntranceDeviceListRequest::pagination_case() const {
  return GetEntranceDeviceListRequest::PaginationCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetEntranceDeviceListResponse_Error

// .keyapis.access_control.v1.ValidationError validation = 1;
inline bool GetEntranceDeviceListResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool GetEntranceDeviceListResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void GetEntranceDeviceListResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::keyapis::access_control::v1::ValidationError* GetEntranceDeviceListResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceDeviceListResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::ValidationError& GetEntranceDeviceListResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::keyapis::access_control::v1::ValidationError&>(::keyapis::access_control::v1::_ValidationError_default_instance_);
}
inline const ::keyapis::access_control::v1::ValidationError& GetEntranceDeviceListResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceDeviceListResponse.Error.validation)
  return _internal_validation();
}
inline ::keyapis::access_control::v1::ValidationError* GetEntranceDeviceListResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.GetEntranceDeviceListResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::keyapis::access_control::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetEntranceDeviceListResponse_Error::unsafe_arena_set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceDeviceListResponse.Error.validation)
}
inline ::keyapis::access_control::v1::ValidationError* GetEntranceDeviceListResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::keyapis::access_control::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::keyapis::access_control::v1::ValidationError* GetEntranceDeviceListResponse_Error::mutable_validation() {
  ::keyapis::access_control::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceDeviceListResponse.Error.validation)
  return _msg;
}

inline bool GetEntranceDeviceListResponse_Error::has_reason() const {
  return reason_case() != REASON_NOT_SET;
}
inline void GetEntranceDeviceListResponse_Error::clear_has_reason() {
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}
inline GetEntranceDeviceListResponse_Error::ReasonCase GetEntranceDeviceListResponse_Error::reason_case() const {
  return GetEntranceDeviceListResponse_Error::ReasonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetEntranceDeviceListResponse

// .keyapis.access_control.v1.EntranceDevice data = 1;
inline bool GetEntranceDeviceListResponse::has_data() const {
  return type_case() == kData;
}
inline bool GetEntranceDeviceListResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void GetEntranceDeviceListResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void GetEntranceDeviceListResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::EntranceDevice* GetEntranceDeviceListResponse::release_data() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceDeviceListResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::access_control::v1::EntranceDevice* temp = _impl_.type_.data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::EntranceDevice& GetEntranceDeviceListResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::keyapis::access_control::v1::EntranceDevice&>(::keyapis::access_control::v1::_EntranceDevice_default_instance_);
}
inline const ::keyapis::access_control::v1::EntranceDevice& GetEntranceDeviceListResponse::data() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceDeviceListResponse.data)
  return _internal_data();
}
inline ::keyapis::access_control::v1::EntranceDevice* GetEntranceDeviceListResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.GetEntranceDeviceListResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::access_control::v1::EntranceDevice* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetEntranceDeviceListResponse::unsafe_arena_set_allocated_data(::keyapis::access_control::v1::EntranceDevice* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceDeviceListResponse.data)
}
inline ::keyapis::access_control::v1::EntranceDevice* GetEntranceDeviceListResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::keyapis::access_control::v1::EntranceDevice >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::keyapis::access_control::v1::EntranceDevice* GetEntranceDeviceListResponse::mutable_data() {
  ::keyapis::access_control::v1::EntranceDevice* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceDeviceListResponse.data)
  return _msg;
}

// .keyapis.access_control.v1.GetEntranceDeviceListResponse.Error error = 2;
inline bool GetEntranceDeviceListResponse::has_error() const {
  return type_case() == kError;
}
inline bool GetEntranceDeviceListResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void GetEntranceDeviceListResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void GetEntranceDeviceListResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* GetEntranceDeviceListResponse::release_error() {
  // @@protoc_insertion_point(field_release:keyapis.access_control.v1.GetEntranceDeviceListResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* temp = _impl_.type_.error_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error& GetEntranceDeviceListResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error&>(::keyapis::access_control::v1::_GetEntranceDeviceListResponse_Error_default_instance_);
}
inline const ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error& GetEntranceDeviceListResponse::error() const {
  // @@protoc_insertion_point(field_get:keyapis.access_control.v1.GetEntranceDeviceListResponse.error)
  return _internal_error();
}
inline ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* GetEntranceDeviceListResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.access_control.v1.GetEntranceDeviceListResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetEntranceDeviceListResponse::unsafe_arena_set_allocated_error(::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.access_control.v1.GetEntranceDeviceListResponse.error)
}
inline ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* GetEntranceDeviceListResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* GetEntranceDeviceListResponse::mutable_error() {
  ::keyapis::access_control::v1::GetEntranceDeviceListResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:keyapis.access_control.v1.GetEntranceDeviceListResponse.error)
  return _msg;
}

inline bool GetEntranceDeviceListResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void GetEntranceDeviceListResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline GetEntranceDeviceListResponse::TypeCase GetEntranceDeviceListResponse::type_case() const {
  return GetEntranceDeviceListResponse::TypeCase(_impl_._oneof_case_[0]);
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace access_control
}  // namespace keyapis


PROTOBUF_NAMESPACE_OPEN

template <>
struct is_proto_enum<::keyapis::access_control::v1::EntranceFilter_CompanyRelationType> : std::true_type {};
template <>
struct is_proto_enum<::keyapis::access_control::v1::EntrancePaging_OrderByType> : std::true_type {};
template <>
struct is_proto_enum<::keyapis::access_control::v1::EntrancePaging_DirectionType> : std::true_type {};
template <>
struct is_proto_enum<::keyapis::access_control::v1::EntranceDevice_RelationType> : std::true_type {};
template <>
struct is_proto_enum<::keyapis::access_control::v1::EntranceDevicePaging_OrderByType> : std::true_type {};
template <>
struct is_proto_enum<::keyapis::access_control::v1::EntranceDevicePaging_DirectionType> : std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_keyapis_2faccess_5fcontrol_2fv1_2fkeyapis_5faccess_5fcontrol_5fentrance_5fv1_2eproto_2epb_2eh