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

#include "keyapis/access_control/v1/keyapis_access_control_room_user_v1.pb.h"

#include <algorithm>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/wire_format_lite.h"
#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal;
namespace keyapis {
namespace access_control {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR RoomUser::RoomUser(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.room_number_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.orpon_)*/ ::int64_t{0}

  , /*decltype(_impl_.user_id_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RoomUserDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RoomUserDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~RoomUserDefaultTypeInternal() {}
  union {
    RoomUser _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RoomUserDefaultTypeInternal _RoomUser_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetRoomUserListRequest::GetRoomUserListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr
  , /*decltype(_impl_.pagination_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetRoomUserListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetRoomUserListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetRoomUserListRequestDefaultTypeInternal() {}
  union {
    GetRoomUserListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetRoomUserListRequestDefaultTypeInternal _GetRoomUserListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetRoomUserListResponse_Error::GetRoomUserListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetRoomUserListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetRoomUserListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetRoomUserListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetRoomUserListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetRoomUserListResponse_ErrorDefaultTypeInternal _GetRoomUserListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetRoomUserListResponse::GetRoomUserListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetRoomUserListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetRoomUserListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetRoomUserListResponseDefaultTypeInternal() {}
  union {
    GetRoomUserListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetRoomUserListResponseDefaultTypeInternal _GetRoomUserListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetRoomUserCountRequest::GetRoomUserCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetRoomUserCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetRoomUserCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetRoomUserCountRequestDefaultTypeInternal() {}
  union {
    GetRoomUserCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetRoomUserCountRequestDefaultTypeInternal _GetRoomUserCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetRoomUserCountResponse::GetRoomUserCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetRoomUserCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetRoomUserCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetRoomUserCountResponseDefaultTypeInternal() {}
  union {
    GetRoomUserCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetRoomUserCountResponseDefaultTypeInternal _GetRoomUserCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR RoomUserFilter::RoomUserFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.orpons_)*/ {}
  ,/* _impl_._orpons_cached_byte_size_ = */ { 0 }

  , /*decltype(_impl_.room_numbers_)*/{}
  , /*decltype(_impl_.user_ids_)*/ {}
  ,/* _impl_._user_ids_cached_byte_size_ = */ { 0 }

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RoomUserFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RoomUserFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~RoomUserFilterDefaultTypeInternal() {}
  union {
    RoomUserFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RoomUserFilterDefaultTypeInternal _RoomUserFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR RoomUserPaging::RoomUserPaging(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.order_by_type_)*/ 0

  , /*decltype(_impl_.direction_type_)*/ 0

  , /*decltype(_impl_.limit_)*/ 0

  , /*decltype(_impl_.offset_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RoomUserPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RoomUserPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~RoomUserPagingDefaultTypeInternal() {}
  union {
    RoomUserPaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RoomUserPagingDefaultTypeInternal _RoomUserPaging_default_instance_;
}  // namespace v1
}  // namespace access_control
}  // namespace keyapis
namespace keyapis {
namespace access_control {
namespace v1 {
bool RoomUserPaging_OrderByType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    RoomUserPaging_OrderByType_strings[3] = {};

static const char RoomUserPaging_OrderByType_names[] = {
    "ORDER_BY_TYPE_UNKNOWN"
    "ORPON_THEN_NUMBER"
    "USER_ID"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry RoomUserPaging_OrderByType_entries[] =
    {
        {{&RoomUserPaging_OrderByType_names[0], 21}, 0},
        {{&RoomUserPaging_OrderByType_names[21], 17}, 2},
        {{&RoomUserPaging_OrderByType_names[38], 7}, 1},
};

static const int RoomUserPaging_OrderByType_entries_by_number[] = {
    0,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    2,  // 1 -> USER_ID
    1,  // 2 -> ORPON_THEN_NUMBER
};

const std::string& RoomUserPaging_OrderByType_Name(RoomUserPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          RoomUserPaging_OrderByType_entries, RoomUserPaging_OrderByType_entries_by_number,
          3, RoomUserPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      RoomUserPaging_OrderByType_entries, RoomUserPaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : RoomUserPaging_OrderByType_strings[idx].get();
}

bool RoomUserPaging_OrderByType_Parse(absl::string_view name, RoomUserPaging_OrderByType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      RoomUserPaging_OrderByType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<RoomUserPaging_OrderByType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr RoomUserPaging_OrderByType RoomUserPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr RoomUserPaging_OrderByType RoomUserPaging::USER_ID;
constexpr RoomUserPaging_OrderByType RoomUserPaging::ORPON_THEN_NUMBER;
constexpr RoomUserPaging_OrderByType RoomUserPaging::OrderByType_MIN;
constexpr RoomUserPaging_OrderByType RoomUserPaging::OrderByType_MAX;
constexpr int RoomUserPaging::OrderByType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool RoomUserPaging_DirectionType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    RoomUserPaging_DirectionType_strings[3] = {};

static const char RoomUserPaging_DirectionType_names[] = {
    "ASC"
    "DESC"
    "DIRECTION_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry RoomUserPaging_DirectionType_entries[] =
    {
        {{&RoomUserPaging_DirectionType_names[0], 3}, 2},
        {{&RoomUserPaging_DirectionType_names[3], 4}, 1},
        {{&RoomUserPaging_DirectionType_names[7], 22}, 0},
};

static const int RoomUserPaging_DirectionType_entries_by_number[] = {
    2,  // 0 -> DIRECTION_TYPE_UNKNOWN
    1,  // 1 -> DESC
    0,  // 2 -> ASC
};

const std::string& RoomUserPaging_DirectionType_Name(RoomUserPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          RoomUserPaging_DirectionType_entries, RoomUserPaging_DirectionType_entries_by_number,
          3, RoomUserPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      RoomUserPaging_DirectionType_entries, RoomUserPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : RoomUserPaging_DirectionType_strings[idx].get();
}

bool RoomUserPaging_DirectionType_Parse(absl::string_view name, RoomUserPaging_DirectionType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      RoomUserPaging_DirectionType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<RoomUserPaging_DirectionType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr RoomUserPaging_DirectionType RoomUserPaging::DIRECTION_TYPE_UNKNOWN;
constexpr RoomUserPaging_DirectionType RoomUserPaging::DESC;
constexpr RoomUserPaging_DirectionType RoomUserPaging::ASC;
constexpr RoomUserPaging_DirectionType RoomUserPaging::DirectionType_MIN;
constexpr RoomUserPaging_DirectionType RoomUserPaging::DirectionType_MAX;
constexpr int RoomUserPaging::DirectionType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
// ===================================================================

class RoomUser::_Internal {
 public:
};

RoomUser::RoomUser(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.RoomUser)
}
RoomUser::RoomUser(const RoomUser& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RoomUser* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.room_number_) {}

    , decltype(_impl_.orpon_) {}

    , decltype(_impl_.user_id_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.room_number_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.room_number_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_room_number().empty()) {
    _this->_impl_.room_number_.Set(from._internal_room_number(), _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.orpon_, &from._impl_.orpon_,
    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.user_id_) -
    reinterpret_cast<char*>(&_impl_.orpon_)) + sizeof(_impl_.user_id_));
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.RoomUser)
}

inline void RoomUser::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.room_number_) {}

    , decltype(_impl_.orpon_) { ::int64_t{0} }

    , decltype(_impl_.user_id_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.room_number_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.room_number_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

RoomUser::~RoomUser() {
  // @@protoc_insertion_point(destructor:keyapis.access_control.v1.RoomUser)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RoomUser::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.room_number_.Destroy();
}

void RoomUser::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RoomUser::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.RoomUser)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.room_number_.ClearToEmpty();
  ::memset(&_impl_.orpon_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.user_id_) -
      reinterpret_cast<char*>(&_impl_.orpon_)) + sizeof(_impl_.user_id_));
  _internal_metadata_.Clear<std::string>();
}

const char* RoomUser::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.orpon_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string room_number = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_room_number();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 user_id = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.user_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RoomUser::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.RoomUser)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_orpon() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
        1, this->_internal_orpon(), target);
  }

  // string room_number = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_room_number().empty()) {
    const std::string& _s = this->_internal_room_number();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_control.v1.RoomUser.room_number");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  // int32 user_id = 3 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_user_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        3, this->_internal_user_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.access_control.v1.RoomUser)
  return target;
}

::size_t RoomUser::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.RoomUser)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string room_number = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_room_number().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_room_number());
  }

  // int64 orpon = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_orpon() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
        this->_internal_orpon());
  }

  // int32 user_id = 3 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_user_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_user_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RoomUser::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RoomUser*>(
      &from));
}

void RoomUser::MergeFrom(const RoomUser& from) {
  RoomUser* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.RoomUser)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_room_number().empty()) {
    _this->_internal_set_room_number(from._internal_room_number());
  }
  if (from._internal_orpon() != 0) {
    _this->_internal_set_orpon(from._internal_orpon());
  }
  if (from._internal_user_id() != 0) {
    _this->_internal_set_user_id(from._internal_user_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RoomUser::CopyFrom(const RoomUser& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.RoomUser)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RoomUser::IsInitialized() const {
  return true;
}

void RoomUser::InternalSwap(RoomUser* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.room_number_, lhs_arena,
                                       &other->_impl_.room_number_, rhs_arena);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RoomUser, _impl_.user_id_)
      + sizeof(RoomUser::_impl_.user_id_)
      - PROTOBUF_FIELD_OFFSET(RoomUser, _impl_.orpon_)>(
          reinterpret_cast<char*>(&_impl_.orpon_),
          reinterpret_cast<char*>(&other->_impl_.orpon_));
}

std::string RoomUser::GetTypeName() const {
  return "keyapis.access_control.v1.RoomUser";
}

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

class GetRoomUserListRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<GetRoomUserListRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GetRoomUserListRequest, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_control::v1::GetRoomUserListRequest, _impl_._oneof_case_);
  static const ::keyapis::access_control::v1::RoomUserFilter& filter(const GetRoomUserListRequest* msg);
  static void set_has_filter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::keyapis::access_control::v1::RoomUserPaging& paging(const GetRoomUserListRequest* msg);
};

const ::keyapis::access_control::v1::RoomUserFilter&
GetRoomUserListRequest::_Internal::filter(const GetRoomUserListRequest* msg) {
  return *msg->_impl_.filter_;
}
const ::keyapis::access_control::v1::RoomUserPaging&
GetRoomUserListRequest::_Internal::paging(const GetRoomUserListRequest* msg) {
  return *msg->_impl_.pagination_.paging_;
}
void GetRoomUserListRequest::set_allocated_paging(::keyapis::access_control::v1::RoomUserPaging* paging) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_pagination();
  if (paging) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paging);
    if (message_arena != submessage_arena) {
      paging = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, paging, submessage_arena);
    }
    set_has_paging();
    _impl_.pagination_.paging_ = paging;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.GetRoomUserListRequest.paging)
}
GetRoomUserListRequest::GetRoomUserListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetRoomUserListRequest)
}
GetRoomUserListRequest::GetRoomUserListRequest(const GetRoomUserListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetRoomUserListRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_control::v1::RoomUserFilter(*from._impl_.filter_);
  }
  clear_has_pagination();
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_control::v1::RoomUserPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetRoomUserListRequest)
}

inline void GetRoomUserListRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_pagination();
}

GetRoomUserListRequest::~GetRoomUserListRequest() {
  // @@protoc_insertion_point(destructor:keyapis.access_control.v1.GetRoomUserListRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetRoomUserListRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.filter_;
  if (has_pagination()) {
    clear_pagination();
  }
}

void GetRoomUserListRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetRoomUserListRequest::clear_pagination() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetRoomUserListRequest)
  switch (pagination_case()) {
    case kPaging: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.pagination_.paging_;
      }
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = PAGINATION_NOT_SET;
}


void GetRoomUserListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetRoomUserListRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  clear_pagination();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetRoomUserListRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.access_control.v1.RoomUserFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_control.v1.RoomUserPaging paging = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_paging(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetRoomUserListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetRoomUserListRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_control.v1.RoomUserFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(this).GetCachedSize(), target, stream);
  }

  // .keyapis.access_control.v1.RoomUserPaging paging = 2;
  if (pagination_case() == kPaging) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::paging(this),
        _Internal::paging(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.access_control.v1.GetRoomUserListRequest)
  return target;
}

::size_t GetRoomUserListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetRoomUserListRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.access_control.v1.RoomUserFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  switch (pagination_case()) {
    // .keyapis.access_control.v1.RoomUserPaging paging = 2;
    case kPaging: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.pagination_.paging_);
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetRoomUserListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetRoomUserListRequest*>(
      &from));
}

void GetRoomUserListRequest::MergeFrom(const GetRoomUserListRequest& from) {
  GetRoomUserListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetRoomUserListRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_filter()->::keyapis::access_control::v1::RoomUserFilter::MergeFrom(
        from._internal_filter());
  }
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_control::v1::RoomUserPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetRoomUserListRequest::CopyFrom(const GetRoomUserListRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.GetRoomUserListRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetRoomUserListRequest::IsInitialized() const {
  return true;
}

void GetRoomUserListRequest::InternalSwap(GetRoomUserListRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.filter_, other->_impl_.filter_);
  swap(_impl_.pagination_, other->_impl_.pagination_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetRoomUserListRequest::GetTypeName() const {
  return "keyapis.access_control.v1.GetRoomUserListRequest";
}

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

class GetRoomUserListResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_control::v1::GetRoomUserListResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::access_control::v1::ValidationError& validation(const GetRoomUserListResponse_Error* msg);
};

const ::keyapis::access_control::v1::ValidationError&
GetRoomUserListResponse_Error::_Internal::validation(const GetRoomUserListResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetRoomUserListResponse_Error::set_allocated_validation(::keyapis::access_control::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.GetRoomUserListResponse.Error.validation)
}
void GetRoomUserListResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetRoomUserListResponse_Error::GetRoomUserListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetRoomUserListResponse.Error)
}
GetRoomUserListResponse_Error::GetRoomUserListResponse_Error(const GetRoomUserListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetRoomUserListResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetRoomUserListResponse.Error)
}

inline void GetRoomUserListResponse_Error::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

GetRoomUserListResponse_Error::~GetRoomUserListResponse_Error() {
  // @@protoc_insertion_point(destructor:keyapis.access_control.v1.GetRoomUserListResponse.Error)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetRoomUserListResponse_Error::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

void GetRoomUserListResponse_Error::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetRoomUserListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetRoomUserListResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetRoomUserListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetRoomUserListResponse.Error)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reason();
  _internal_metadata_.Clear<std::string>();
}

const char* GetRoomUserListResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.access_control.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetRoomUserListResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetRoomUserListResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.access_control.v1.GetRoomUserListResponse.Error)
  return target;
}

::size_t GetRoomUserListResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetRoomUserListResponse.Error)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (reason_case()) {
    // .keyapis.access_control.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetRoomUserListResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetRoomUserListResponse_Error*>(
      &from));
}

void GetRoomUserListResponse_Error::MergeFrom(const GetRoomUserListResponse_Error& from) {
  GetRoomUserListResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetRoomUserListResponse.Error)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetRoomUserListResponse_Error::CopyFrom(const GetRoomUserListResponse_Error& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.GetRoomUserListResponse.Error)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetRoomUserListResponse_Error::IsInitialized() const {
  return true;
}

void GetRoomUserListResponse_Error::InternalSwap(GetRoomUserListResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetRoomUserListResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.GetRoomUserListResponse.Error";
}

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

class GetRoomUserListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_control::v1::GetRoomUserListResponse, _impl_._oneof_case_);
  static const ::keyapis::access_control::v1::RoomUser& data(const GetRoomUserListResponse* msg);
  static const ::keyapis::access_control::v1::GetRoomUserListResponse_Error& error(const GetRoomUserListResponse* msg);
};

const ::keyapis::access_control::v1::RoomUser&
GetRoomUserListResponse::_Internal::data(const GetRoomUserListResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::access_control::v1::GetRoomUserListResponse_Error&
GetRoomUserListResponse::_Internal::error(const GetRoomUserListResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetRoomUserListResponse::set_allocated_data(::keyapis::access_control::v1::RoomUser* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  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);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.GetRoomUserListResponse.data)
}
void GetRoomUserListResponse::set_allocated_error(::keyapis::access_control::v1::GetRoomUserListResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_control.v1.GetRoomUserListResponse.error)
}
GetRoomUserListResponse::GetRoomUserListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetRoomUserListResponse)
}
GetRoomUserListResponse::GetRoomUserListResponse(const GetRoomUserListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetRoomUserListResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::access_control::v1::RoomUser::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_control::v1::GetRoomUserListResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetRoomUserListResponse)
}

inline void GetRoomUserListResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetRoomUserListResponse::~GetRoomUserListResponse() {
  // @@protoc_insertion_point(destructor:keyapis.access_control.v1.GetRoomUserListResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetRoomUserListResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetRoomUserListResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetRoomUserListResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetRoomUserListResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.error_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetRoomUserListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetRoomUserListResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetRoomUserListResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.access_control.v1.RoomUser data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_control.v1.GetRoomUserListResponse.Error error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetRoomUserListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetRoomUserListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kData: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::data(this),
          _Internal::data(this).GetCachedSize(), target, stream);
      break;
    }
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.access_control.v1.GetRoomUserListResponse)
  return target;
}

::size_t GetRoomUserListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetRoomUserListResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.access_control.v1.RoomUser data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    // .keyapis.access_control.v1.GetRoomUserListResponse.Error error = 2;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetRoomUserListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetRoomUserListResponse*>(
      &from));
}

void GetRoomUserListResponse::MergeFrom(const GetRoomUserListResponse& from) {
  GetRoomUserListResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetRoomUserListResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::access_control::v1::RoomUser::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_control::v1::GetRoomUserListResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetRoomUserListResponse::CopyFrom(const GetRoomUserListResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.GetRoomUserListResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetRoomUserListResponse::IsInitialized() const {
  return true;
}

void GetRoomUserListResponse::InternalSwap(GetRoomUserListResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetRoomUserListResponse::GetTypeName() const {
  return "keyapis.access_control.v1.GetRoomUserListResponse";
}

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

class GetRoomUserCountRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<GetRoomUserCountRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GetRoomUserCountRequest, _impl_._has_bits_);
  static const ::keyapis::access_control::v1::RoomUserFilter& filter(const GetRoomUserCountRequest* msg);
  static void set_has_filter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::keyapis::access_control::v1::RoomUserFilter&
GetRoomUserCountRequest::_Internal::filter(const GetRoomUserCountRequest* msg) {
  return *msg->_impl_.filter_;
}
GetRoomUserCountRequest::GetRoomUserCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetRoomUserCountRequest)
}
GetRoomUserCountRequest::GetRoomUserCountRequest(const GetRoomUserCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetRoomUserCountRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_control::v1::RoomUserFilter(*from._impl_.filter_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetRoomUserCountRequest)
}

inline void GetRoomUserCountRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
  };
}

GetRoomUserCountRequest::~GetRoomUserCountRequest() {
  // @@protoc_insertion_point(destructor:keyapis.access_control.v1.GetRoomUserCountRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetRoomUserCountRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.filter_;
}

void GetRoomUserCountRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetRoomUserCountRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetRoomUserCountRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetRoomUserCountRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.access_control.v1.RoomUserFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetRoomUserCountRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetRoomUserCountRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_control.v1.RoomUserFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.access_control.v1.GetRoomUserCountRequest)
  return target;
}

::size_t GetRoomUserCountRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetRoomUserCountRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.access_control.v1.RoomUserFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetRoomUserCountRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetRoomUserCountRequest*>(
      &from));
}

void GetRoomUserCountRequest::MergeFrom(const GetRoomUserCountRequest& from) {
  GetRoomUserCountRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetRoomUserCountRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_filter()->::keyapis::access_control::v1::RoomUserFilter::MergeFrom(
        from._internal_filter());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetRoomUserCountRequest::CopyFrom(const GetRoomUserCountRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.GetRoomUserCountRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetRoomUserCountRequest::IsInitialized() const {
  return true;
}

void GetRoomUserCountRequest::InternalSwap(GetRoomUserCountRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.filter_, other->_impl_.filter_);
}

std::string GetRoomUserCountRequest::GetTypeName() const {
  return "keyapis.access_control.v1.GetRoomUserCountRequest";
}

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

class GetRoomUserCountResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_control::v1::GetRoomUserCountResponse, _impl_._oneof_case_);
};

GetRoomUserCountResponse::GetRoomUserCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetRoomUserCountResponse)
}
GetRoomUserCountResponse::GetRoomUserCountResponse(const GetRoomUserCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetRoomUserCountResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetRoomUserCountResponse)
}

inline void GetRoomUserCountResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetRoomUserCountResponse::~GetRoomUserCountResponse() {
  // @@protoc_insertion_point(destructor:keyapis.access_control.v1.GetRoomUserCountResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetRoomUserCountResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetRoomUserCountResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetRoomUserCountResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetRoomUserCountResponse)
  switch (type_case()) {
    case kData: {
      // No need to clear
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetRoomUserCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetRoomUserCountResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetRoomUserCountResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetRoomUserCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetRoomUserCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 data = 1;
  if (type_case() == kData) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.access_control.v1.GetRoomUserCountResponse)
  return target;
}

::size_t GetRoomUserCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetRoomUserCountResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetRoomUserCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetRoomUserCountResponse*>(
      &from));
}

void GetRoomUserCountResponse::MergeFrom(const GetRoomUserCountResponse& from) {
  GetRoomUserCountResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetRoomUserCountResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetRoomUserCountResponse::CopyFrom(const GetRoomUserCountResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.GetRoomUserCountResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetRoomUserCountResponse::IsInitialized() const {
  return true;
}

void GetRoomUserCountResponse::InternalSwap(GetRoomUserCountResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetRoomUserCountResponse::GetTypeName() const {
  return "keyapis.access_control.v1.GetRoomUserCountResponse";
}

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

class RoomUserFilter::_Internal {
 public:
};

RoomUserFilter::RoomUserFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.RoomUserFilter)
}
RoomUserFilter::RoomUserFilter(const RoomUserFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RoomUserFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.orpons_) { from._impl_.orpons_ }
    ,/* _impl_._orpons_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.room_numbers_){from._impl_.room_numbers_}
    , decltype(_impl_.user_ids_) { from._impl_.user_ids_ }
    ,/* _impl_._user_ids_cached_byte_size_ = */ { 0 }

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.RoomUserFilter)
}

inline void RoomUserFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.orpons_) { arena }
    ,/* _impl_._orpons_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.room_numbers_){arena}
    , decltype(_impl_.user_ids_) { arena }
    ,/* _impl_._user_ids_cached_byte_size_ = */ { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
}

RoomUserFilter::~RoomUserFilter() {
  // @@protoc_insertion_point(destructor:keyapis.access_control.v1.RoomUserFilter)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RoomUserFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.orpons_.~RepeatedField();
  _internal_mutable_room_numbers()->~RepeatedPtrField();
  _impl_.user_ids_.~RepeatedField();
}

void RoomUserFilter::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RoomUserFilter::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.RoomUserFilter)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_mutable_orpons()->Clear();
  _internal_mutable_room_numbers()->Clear();
  _internal_mutable_user_ids()->Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* RoomUserFilter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated int64 orpons = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_orpons(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 8) {
          _internal_add_orpons(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string room_numbers = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_room_numbers();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int32 user_ids = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_user_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 24) {
          _internal_add_user_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RoomUserFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.RoomUserFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int64 orpons = 1;
  {
    int byte_size = _impl_._orpons_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt64Packed(1, _internal_orpons(),
                                                 byte_size, target);
    }
  }

  // repeated string room_numbers = 2;
  for (int i = 0, n = this->_internal_room_numbers_size(); i < n; ++i) {
    const auto& s = this->_internal_room_numbers(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_control.v1.RoomUserFilter.room_numbers");
    target = stream->WriteString(2, s, target);
  }

  // repeated int32 user_ids = 3;
  {
    int byte_size = _impl_._user_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(3, _internal_user_ids(),
                                                 byte_size, target);
    }
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.access_control.v1.RoomUserFilter)
  return target;
}

::size_t RoomUserFilter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.RoomUserFilter)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int64 orpons = 1;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int64Size(
        this->_internal_orpons())
    ;
    _impl_._orpons_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
    std::size_t tag_size = data_size == 0
        ? 0
        : 1 + ::_pbi::WireFormatLite::Int32Size(
                            static_cast<int32_t>(data_size))
    ;
    total_size += tag_size + data_size;
  }

  // repeated string room_numbers = 2;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_room_numbers().size());
  for (int i = 0, n = _internal_room_numbers().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_room_numbers().Get(i));
  }

  // repeated int32 user_ids = 3;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
        this->_internal_user_ids())
    ;
    _impl_._user_ids_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
    std::size_t tag_size = data_size == 0
        ? 0
        : 1 + ::_pbi::WireFormatLite::Int32Size(
                            static_cast<int32_t>(data_size))
    ;
    total_size += tag_size + data_size;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RoomUserFilter::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RoomUserFilter*>(
      &from));
}

void RoomUserFilter::MergeFrom(const RoomUserFilter& from) {
  RoomUserFilter* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.RoomUserFilter)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.orpons_.MergeFrom(from._impl_.orpons_);
  _this->_internal_mutable_room_numbers()->MergeFrom(from._internal_room_numbers());
  _this->_impl_.user_ids_.MergeFrom(from._impl_.user_ids_);
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RoomUserFilter::CopyFrom(const RoomUserFilter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.RoomUserFilter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RoomUserFilter::IsInitialized() const {
  return true;
}

void RoomUserFilter::InternalSwap(RoomUserFilter* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.orpons_.InternalSwap(&other->_impl_.orpons_);
  _internal_mutable_room_numbers()->InternalSwap(
      other->_internal_mutable_room_numbers());
  _impl_.user_ids_.InternalSwap(&other->_impl_.user_ids_);
}

std::string RoomUserFilter::GetTypeName() const {
  return "keyapis.access_control.v1.RoomUserFilter";
}

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

class RoomUserPaging::_Internal {
 public:
};

RoomUserPaging::RoomUserPaging(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.RoomUserPaging)
}
RoomUserPaging::RoomUserPaging(const RoomUserPaging& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.RoomUserPaging)
}

inline void RoomUserPaging::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.order_by_type_) { 0 }

    , decltype(_impl_.direction_type_) { 0 }

    , decltype(_impl_.limit_) { 0 }

    , decltype(_impl_.offset_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
}

RoomUserPaging::~RoomUserPaging() {
  // @@protoc_insertion_point(destructor:keyapis.access_control.v1.RoomUserPaging)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RoomUserPaging::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void RoomUserPaging::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RoomUserPaging::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.RoomUserPaging)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&_impl_.order_by_type_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.offset_) -
      reinterpret_cast<char*>(&_impl_.order_by_type_)) + sizeof(_impl_.offset_));
  _internal_metadata_.Clear<std::string>();
}

const char* RoomUserPaging::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.access_control.v1.RoomUserPaging.OrderByType order_by_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_order_by_type(static_cast<::keyapis::access_control::v1::RoomUserPaging_OrderByType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_control.v1.RoomUserPaging.DirectionType direction_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_direction_type(static_cast<::keyapis::access_control::v1::RoomUserPaging_DirectionType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 limit = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 offset = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RoomUserPaging::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.RoomUserPaging)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.v1.RoomUserPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_order_by_type(), target);
  }

  // .keyapis.access_control.v1.RoomUserPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this->_internal_direction_type(), target);
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        3, this->_internal_limit(), target);
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        4, this->_internal_offset(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.access_control.v1.RoomUserPaging)
  return target;
}

::size_t RoomUserPaging::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.RoomUserPaging)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.access_control.v1.RoomUserPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_order_by_type());
  }

  // .keyapis.access_control.v1.RoomUserPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_direction_type());
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_limit());
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_offset());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RoomUserPaging::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RoomUserPaging*>(
      &from));
}

void RoomUserPaging::MergeFrom(const RoomUserPaging& from) {
  RoomUserPaging* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.RoomUserPaging)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_order_by_type() != 0) {
    _this->_internal_set_order_by_type(from._internal_order_by_type());
  }
  if (from._internal_direction_type() != 0) {
    _this->_internal_set_direction_type(from._internal_direction_type());
  }
  if (from._internal_limit() != 0) {
    _this->_internal_set_limit(from._internal_limit());
  }
  if (from._internal_offset() != 0) {
    _this->_internal_set_offset(from._internal_offset());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RoomUserPaging::CopyFrom(const RoomUserPaging& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.RoomUserPaging)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RoomUserPaging::IsInitialized() const {
  return true;
}

void RoomUserPaging::InternalSwap(RoomUserPaging* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RoomUserPaging, _impl_.offset_)
      + sizeof(RoomUserPaging::_impl_.offset_)
      - PROTOBUF_FIELD_OFFSET(RoomUserPaging, _impl_.order_by_type_)>(
          reinterpret_cast<char*>(&_impl_.order_by_type_),
          reinterpret_cast<char*>(&other->_impl_.order_by_type_));
}

std::string RoomUserPaging::GetTypeName() const {
  return "keyapis.access_control.v1.RoomUserPaging";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace access_control
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::RoomUser*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::RoomUser >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::RoomUser >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetRoomUserListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetRoomUserListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetRoomUserListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetRoomUserListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetRoomUserListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetRoomUserListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetRoomUserListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetRoomUserListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetRoomUserListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetRoomUserCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetRoomUserCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetRoomUserCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetRoomUserCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetRoomUserCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetRoomUserCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::RoomUserFilter*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::RoomUserFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::RoomUserFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::RoomUserPaging*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::RoomUserPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::RoomUserPaging >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"