// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: deviceapis/device/v1/deviceapis_device_room_v1.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_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 "deviceapis/device/v1/deviceapis_device_common_v1.pb.h"
#include "google/api/annotations.pb.h"
#include "google/api/field_behavior.pb.h"
#include "protoc-gen-openapiv2/options/annotations.pb.h"
// @@protoc_insertion_point(includes)

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

#define PROTOBUF_INTERNAL_EXPORT_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto

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

// Internal implementation detail -- do not use these members.
struct TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto {
  static const ::uint32_t offsets[];
};
namespace deviceapis {
namespace device {
namespace v1 {
class DeleteRoomListRequest;
struct DeleteRoomListRequestDefaultTypeInternal;
extern DeleteRoomListRequestDefaultTypeInternal _DeleteRoomListRequest_default_instance_;
class DeleteRoomListResponse;
struct DeleteRoomListResponseDefaultTypeInternal;
extern DeleteRoomListResponseDefaultTypeInternal _DeleteRoomListResponse_default_instance_;
class DeleteRoomListResponse_Error;
struct DeleteRoomListResponse_ErrorDefaultTypeInternal;
extern DeleteRoomListResponse_ErrorDefaultTypeInternal _DeleteRoomListResponse_Error_default_instance_;
class DeleteRoomRequest;
struct DeleteRoomRequestDefaultTypeInternal;
extern DeleteRoomRequestDefaultTypeInternal _DeleteRoomRequest_default_instance_;
class DeleteRoomResponse;
struct DeleteRoomResponseDefaultTypeInternal;
extern DeleteRoomResponseDefaultTypeInternal _DeleteRoomResponse_default_instance_;
class DeleteRoomResponse_Error;
struct DeleteRoomResponse_ErrorDefaultTypeInternal;
extern DeleteRoomResponse_ErrorDefaultTypeInternal _DeleteRoomResponse_Error_default_instance_;
class GetRoomCountRequest;
struct GetRoomCountRequestDefaultTypeInternal;
extern GetRoomCountRequestDefaultTypeInternal _GetRoomCountRequest_default_instance_;
class GetRoomCountResponse;
struct GetRoomCountResponseDefaultTypeInternal;
extern GetRoomCountResponseDefaultTypeInternal _GetRoomCountResponse_default_instance_;
class GetRoomListRequest;
struct GetRoomListRequestDefaultTypeInternal;
extern GetRoomListRequestDefaultTypeInternal _GetRoomListRequest_default_instance_;
class GetRoomListResponse;
struct GetRoomListResponseDefaultTypeInternal;
extern GetRoomListResponseDefaultTypeInternal _GetRoomListResponse_default_instance_;
class GetRoomRequest;
struct GetRoomRequestDefaultTypeInternal;
extern GetRoomRequestDefaultTypeInternal _GetRoomRequest_default_instance_;
class GetRoomResponse;
struct GetRoomResponseDefaultTypeInternal;
extern GetRoomResponseDefaultTypeInternal _GetRoomResponse_default_instance_;
class Room;
struct RoomDefaultTypeInternal;
extern RoomDefaultTypeInternal _Room_default_instance_;
class RoomFilter;
struct RoomFilterDefaultTypeInternal;
extern RoomFilterDefaultTypeInternal _RoomFilter_default_instance_;
class RoomPaging;
struct RoomPagingDefaultTypeInternal;
extern RoomPagingDefaultTypeInternal _RoomPaging_default_instance_;
class SaveRoomListRequest;
struct SaveRoomListRequestDefaultTypeInternal;
extern SaveRoomListRequestDefaultTypeInternal _SaveRoomListRequest_default_instance_;
class SaveRoomListResponse;
struct SaveRoomListResponseDefaultTypeInternal;
extern SaveRoomListResponseDefaultTypeInternal _SaveRoomListResponse_default_instance_;
class SaveRoomListResponse_Error;
struct SaveRoomListResponse_ErrorDefaultTypeInternal;
extern SaveRoomListResponse_ErrorDefaultTypeInternal _SaveRoomListResponse_Error_default_instance_;
class SaveRoomRequest;
struct SaveRoomRequestDefaultTypeInternal;
extern SaveRoomRequestDefaultTypeInternal _SaveRoomRequest_default_instance_;
class SaveRoomResponse;
struct SaveRoomResponseDefaultTypeInternal;
extern SaveRoomResponseDefaultTypeInternal _SaveRoomResponse_default_instance_;
class SaveRoomResponse_Error;
struct SaveRoomResponse_ErrorDefaultTypeInternal;
extern SaveRoomResponse_ErrorDefaultTypeInternal _SaveRoomResponse_Error_default_instance_;
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
PROTOBUF_NAMESPACE_OPEN
template <>
::deviceapis::device::v1::DeleteRoomListRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRoomListRequest>(Arena*);
template <>
::deviceapis::device::v1::DeleteRoomListResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRoomListResponse>(Arena*);
template <>
::deviceapis::device::v1::DeleteRoomListResponse_Error* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRoomListResponse_Error>(Arena*);
template <>
::deviceapis::device::v1::DeleteRoomRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRoomRequest>(Arena*);
template <>
::deviceapis::device::v1::DeleteRoomResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRoomResponse>(Arena*);
template <>
::deviceapis::device::v1::DeleteRoomResponse_Error* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRoomResponse_Error>(Arena*);
template <>
::deviceapis::device::v1::GetRoomCountRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRoomCountRequest>(Arena*);
template <>
::deviceapis::device::v1::GetRoomCountResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRoomCountResponse>(Arena*);
template <>
::deviceapis::device::v1::GetRoomListRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRoomListRequest>(Arena*);
template <>
::deviceapis::device::v1::GetRoomListResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRoomListResponse>(Arena*);
template <>
::deviceapis::device::v1::GetRoomRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRoomRequest>(Arena*);
template <>
::deviceapis::device::v1::GetRoomResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRoomResponse>(Arena*);
template <>
::deviceapis::device::v1::Room* Arena::CreateMaybeMessage<::deviceapis::device::v1::Room>(Arena*);
template <>
::deviceapis::device::v1::RoomFilter* Arena::CreateMaybeMessage<::deviceapis::device::v1::RoomFilter>(Arena*);
template <>
::deviceapis::device::v1::RoomPaging* Arena::CreateMaybeMessage<::deviceapis::device::v1::RoomPaging>(Arena*);
template <>
::deviceapis::device::v1::SaveRoomListRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRoomListRequest>(Arena*);
template <>
::deviceapis::device::v1::SaveRoomListResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRoomListResponse>(Arena*);
template <>
::deviceapis::device::v1::SaveRoomListResponse_Error* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRoomListResponse_Error>(Arena*);
template <>
::deviceapis::device::v1::SaveRoomRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRoomRequest>(Arena*);
template <>
::deviceapis::device::v1::SaveRoomResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRoomResponse>(Arena*);
template <>
::deviceapis::device::v1::SaveRoomResponse_Error* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRoomResponse_Error>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace deviceapis {
namespace device {
namespace v1 {

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


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

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

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

  inline DeleteRoomListRequest& operator=(const DeleteRoomListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteRoomListRequest& operator=(DeleteRoomListRequest&& 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 DeleteRoomListRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeleteRoomListRequest* internal_default_instance() {
    return reinterpret_cast<const DeleteRoomListRequest*>(
               &_DeleteRoomListRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(DeleteRoomListRequest& a, DeleteRoomListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteRoomListRequest* 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(DeleteRoomListRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DeleteRoomListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteRoomListRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteRoomListRequest& from);
  void MergeFrom(const DeleteRoomListRequest& 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(DeleteRoomListRequest* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kFilterFieldNumber = 1,
  };
  // .deviceapis.device.v1.RoomFilter filter = 1;
  bool has_filter() const;
  void clear_filter() ;
  const ::deviceapis::device::v1::RoomFilter& filter() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::RoomFilter* release_filter();
  ::deviceapis::device::v1::RoomFilter* mutable_filter();
  void set_allocated_filter(::deviceapis::device::v1::RoomFilter* filter);
  private:
  const ::deviceapis::device::v1::RoomFilter& _internal_filter() const;
  ::deviceapis::device::v1::RoomFilter* _internal_mutable_filter();
  public:
  void unsafe_arena_set_allocated_filter(
      ::deviceapis::device::v1::RoomFilter* filter);
  ::deviceapis::device::v1::RoomFilter* unsafe_arena_release_filter();
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.DeleteRoomListRequest)
 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_;
    ::deviceapis::device::v1::RoomFilter* filter_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

  inline DeleteRoomListResponse_Error& operator=(const DeleteRoomListResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteRoomListResponse_Error& operator=(DeleteRoomListResponse_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 DeleteRoomListResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

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

  friend void swap(DeleteRoomListResponse_Error& a, DeleteRoomListResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteRoomListResponse_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(DeleteRoomListResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DeleteRoomListResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteRoomListResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteRoomListResponse_Error& from);
  void MergeFrom(const DeleteRoomListResponse_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(DeleteRoomListResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.DeleteRoomListResponse.Error";
  }
  protected:
  explicit DeleteRoomListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

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

  public:
  void clear_validation() ;
  const ::deviceapis::device::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::ValidationError* release_validation();
  ::deviceapis::device::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::deviceapis::device::v1::ValidationError* validation);
  private:
  const ::deviceapis::device::v1::ValidationError& _internal_validation() const;
  ::deviceapis::device::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::deviceapis::device::v1::ValidationError* validation);
  ::deviceapis::device::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.DeleteRoomListResponse.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_;
      ::deviceapis::device::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline DeleteRoomListResponse& operator=(const DeleteRoomListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteRoomListResponse& operator=(DeleteRoomListResponse&& 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 DeleteRoomListResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    kError = 2,
    TYPE_NOT_SET = 0,
  };

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

  friend void swap(DeleteRoomListResponse& a, DeleteRoomListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteRoomListResponse* 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(DeleteRoomListResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DeleteRoomListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteRoomListResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteRoomListResponse& from);
  void MergeFrom(const DeleteRoomListResponse& 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(DeleteRoomListResponse* other);

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

  std::string GetTypeName() const final;

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

  typedef DeleteRoomListResponse_Error Error;

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

  enum : int {
    kDataFieldNumber = 1,
    kErrorFieldNumber = 2,
  };
  // int32 data = 1;
  bool has_data() const;
  void clear_data() ;
  ::int32_t data() const;
  void set_data(::int32_t value);

  private:
  ::int32_t _internal_data() const;
  void _internal_set_data(::int32_t value);

  public:
  // .deviceapis.device.v1.DeleteRoomListResponse.Error error = 2;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::deviceapis::device::v1::DeleteRoomListResponse_Error& error() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::DeleteRoomListResponse_Error* release_error();
  ::deviceapis::device::v1::DeleteRoomListResponse_Error* mutable_error();
  void set_allocated_error(::deviceapis::device::v1::DeleteRoomListResponse_Error* error);
  private:
  const ::deviceapis::device::v1::DeleteRoomListResponse_Error& _internal_error() const;
  ::deviceapis::device::v1::DeleteRoomListResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::deviceapis::device::v1::DeleteRoomListResponse_Error* error);
  ::deviceapis::device::v1::DeleteRoomListResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.DeleteRoomListResponse)
 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_;
      ::int32_t data_;
      ::deviceapis::device::v1::DeleteRoomListResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline DeleteRoomRequest& operator=(const DeleteRoomRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteRoomRequest& operator=(DeleteRoomRequest&& 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 DeleteRoomRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeleteRoomRequest* internal_default_instance() {
    return reinterpret_cast<const DeleteRoomRequest*>(
               &_DeleteRoomRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(DeleteRoomRequest& a, DeleteRoomRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteRoomRequest* 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(DeleteRoomRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DeleteRoomRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteRoomRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteRoomRequest& from);
  void MergeFrom(const DeleteRoomRequest& 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(DeleteRoomRequest* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kRoomNumberFieldNumber = 1,
  };
  // string room_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_room_number() ;
  const std::string& room_number() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_room_number(Arg_&& arg, Args_... args);
  std::string* mutable_room_number();
  PROTOBUF_NODISCARD std::string* release_room_number();
  void set_allocated_room_number(std::string* ptr);

  private:
  const std::string& _internal_room_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_room_number(
      const std::string& value);
  std::string* _internal_mutable_room_number();

  public:
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.DeleteRoomRequest)
 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::ArenaStringPtr room_number_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

  inline DeleteRoomResponse_Error& operator=(const DeleteRoomResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteRoomResponse_Error& operator=(DeleteRoomResponse_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 DeleteRoomResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

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

  friend void swap(DeleteRoomResponse_Error& a, DeleteRoomResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteRoomResponse_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(DeleteRoomResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DeleteRoomResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteRoomResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteRoomResponse_Error& from);
  void MergeFrom(const DeleteRoomResponse_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(DeleteRoomResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.DeleteRoomResponse.Error";
  }
  protected:
  explicit DeleteRoomResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

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

  public:
  void clear_validation() ;
  const ::deviceapis::device::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::ValidationError* release_validation();
  ::deviceapis::device::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::deviceapis::device::v1::ValidationError* validation);
  private:
  const ::deviceapis::device::v1::ValidationError& _internal_validation() const;
  ::deviceapis::device::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::deviceapis::device::v1::ValidationError* validation);
  ::deviceapis::device::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.DeleteRoomResponse.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_;
      ::deviceapis::device::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline DeleteRoomResponse& operator=(const DeleteRoomResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteRoomResponse& operator=(DeleteRoomResponse&& 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 DeleteRoomResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kError = 1,
    TYPE_NOT_SET = 0,
  };

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

  friend void swap(DeleteRoomResponse& a, DeleteRoomResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteRoomResponse* 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(DeleteRoomResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DeleteRoomResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteRoomResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DeleteRoomResponse& from);
  void MergeFrom(const DeleteRoomResponse& 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(DeleteRoomResponse* other);

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

  std::string GetTypeName() const final;

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

  typedef DeleteRoomResponse_Error Error;

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

  enum : int {
    kErrorFieldNumber = 1,
  };
  // .deviceapis.device.v1.DeleteRoomResponse.Error error = 1;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::deviceapis::device::v1::DeleteRoomResponse_Error& error() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::DeleteRoomResponse_Error* release_error();
  ::deviceapis::device::v1::DeleteRoomResponse_Error* mutable_error();
  void set_allocated_error(::deviceapis::device::v1::DeleteRoomResponse_Error* error);
  private:
  const ::deviceapis::device::v1::DeleteRoomResponse_Error& _internal_error() const;
  ::deviceapis::device::v1::DeleteRoomResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::deviceapis::device::v1::DeleteRoomResponse_Error* error);
  ::deviceapis::device::v1::DeleteRoomResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.DeleteRoomResponse)
 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_;
      ::deviceapis::device::v1::DeleteRoomResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline GetRoomCountRequest& operator=(const GetRoomCountRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetRoomCountRequest& operator=(GetRoomCountRequest&& 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 GetRoomCountRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const GetRoomCountRequest* internal_default_instance() {
    return reinterpret_cast<const GetRoomCountRequest*>(
               &_GetRoomCountRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(GetRoomCountRequest& a, GetRoomCountRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetRoomCountRequest* 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(GetRoomCountRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetRoomCountRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetRoomCountRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetRoomCountRequest& from);
  void MergeFrom(const GetRoomCountRequest& 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(GetRoomCountRequest* other);

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

  std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRoomCountRequest)
 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_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

  inline GetRoomCountResponse& operator=(const GetRoomCountResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetRoomCountResponse& operator=(GetRoomCountResponse&& 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 GetRoomCountResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    TYPE_NOT_SET = 0,
  };

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

  friend void swap(GetRoomCountResponse& a, GetRoomCountResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetRoomCountResponse* 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(GetRoomCountResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetRoomCountResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetRoomCountResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetRoomCountResponse& from);
  void MergeFrom(const GetRoomCountResponse& 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(GetRoomCountResponse* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // int32 data = 1;
  bool has_data() const;
  void clear_data() ;
  ::int32_t data() const;
  void set_data(::int32_t value);

  private:
  ::int32_t _internal_data() const;
  void _internal_set_data(::int32_t value);

  public:
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRoomCountResponse)
 private:
  class _Internal;
  void set_has_data();

  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_;
      ::int32_t data_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline GetRoomListRequest& operator=(const GetRoomListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetRoomListRequest& operator=(GetRoomListRequest&& 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 GetRoomListRequest& default_instance() {
    return *internal_default_instance();
  }
  enum PaginationCase {
    kPaging = 1,
    PAGINATION_NOT_SET = 0,
  };

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

  friend void swap(GetRoomListRequest& a, GetRoomListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetRoomListRequest* 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(GetRoomListRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetRoomListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetRoomListRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetRoomListRequest& from);
  void MergeFrom(const GetRoomListRequest& 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(GetRoomListRequest* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kPagingFieldNumber = 1,
  };
  // .deviceapis.device.v1.RoomPaging paging = 1;
  bool has_paging() const;
  private:
  bool _internal_has_paging() const;

  public:
  void clear_paging() ;
  const ::deviceapis::device::v1::RoomPaging& paging() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::RoomPaging* release_paging();
  ::deviceapis::device::v1::RoomPaging* mutable_paging();
  void set_allocated_paging(::deviceapis::device::v1::RoomPaging* paging);
  private:
  const ::deviceapis::device::v1::RoomPaging& _internal_paging() const;
  ::deviceapis::device::v1::RoomPaging* _internal_mutable_paging();
  public:
  void unsafe_arena_set_allocated_paging(
      ::deviceapis::device::v1::RoomPaging* paging);
  ::deviceapis::device::v1::RoomPaging* unsafe_arena_release_paging();
  void clear_pagination();
  PaginationCase pagination_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRoomListRequest)
 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_ {
    union PaginationUnion {
      constexpr PaginationUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::deviceapis::device::v1::RoomPaging* paging_;
    } pagination_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline GetRoomListResponse& operator=(const GetRoomListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetRoomListResponse& operator=(GetRoomListResponse&& 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 GetRoomListResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const GetRoomListResponse* internal_default_instance() {
    return reinterpret_cast<const GetRoomListResponse*>(
               &_GetRoomListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(GetRoomListResponse& a, GetRoomListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetRoomListResponse* 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(GetRoomListResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetRoomListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetRoomListResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetRoomListResponse& from);
  void MergeFrom(const GetRoomListResponse& 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(GetRoomListResponse* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated .deviceapis.device.v1.Room data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;

  public:
  void clear_data() ;
  ::deviceapis::device::v1::Room* mutable_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >*
      mutable_data();
  private:
  const ::deviceapis::device::v1::Room& _internal_data(int index) const;
  ::deviceapis::device::v1::Room* _internal_add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>& _internal_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>* _internal_mutable_data();
  public:
  const ::deviceapis::device::v1::Room& data(int index) const;
  ::deviceapis::device::v1::Room* add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >&
      data() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRoomListResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room > data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

  inline GetRoomRequest& operator=(const GetRoomRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetRoomRequest& operator=(GetRoomRequest&& 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 GetRoomRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const GetRoomRequest* internal_default_instance() {
    return reinterpret_cast<const GetRoomRequest*>(
               &_GetRoomRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(GetRoomRequest& a, GetRoomRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetRoomRequest* 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(GetRoomRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetRoomRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetRoomRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetRoomRequest& from);
  void MergeFrom(const GetRoomRequest& 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(GetRoomRequest* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kRoomNumberFieldNumber = 1,
  };
  // string room_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_room_number() ;
  const std::string& room_number() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_room_number(Arg_&& arg, Args_... args);
  std::string* mutable_room_number();
  PROTOBUF_NODISCARD std::string* release_room_number();
  void set_allocated_room_number(std::string* ptr);

  private:
  const std::string& _internal_room_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_room_number(
      const std::string& value);
  std::string* _internal_mutable_room_number();

  public:
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRoomRequest)
 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::ArenaStringPtr room_number_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

  inline GetRoomResponse& operator=(const GetRoomResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetRoomResponse& operator=(GetRoomResponse&& 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 GetRoomResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    TYPE_NOT_SET = 0,
  };

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

  friend void swap(GetRoomResponse& a, GetRoomResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetRoomResponse* 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(GetRoomResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetRoomResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetRoomResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetRoomResponse& from);
  void MergeFrom(const GetRoomResponse& 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(GetRoomResponse* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // .deviceapis.device.v1.Room data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::deviceapis::device::v1::Room& data() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::Room* release_data();
  ::deviceapis::device::v1::Room* mutable_data();
  void set_allocated_data(::deviceapis::device::v1::Room* data);
  private:
  const ::deviceapis::device::v1::Room& _internal_data() const;
  ::deviceapis::device::v1::Room* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::deviceapis::device::v1::Room* data);
  ::deviceapis::device::v1::Room* unsafe_arena_release_data();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRoomResponse)
 private:
  class _Internal;
  void set_has_data();

  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_;
      ::deviceapis::device::v1::Room* data_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline Room& operator=(const Room& from) {
    CopyFrom(from);
    return *this;
  }
  inline Room& operator=(Room&& 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 Room& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kAnalogPhoneCmsNumber = 3,
    kAnalogPhoneDigitalNumber = 4,
    TYPE_NOT_SET = 0,
  };

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

  friend void swap(Room& a, Room& b) {
    a.Swap(&b);
  }
  inline void Swap(Room* 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(Room* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Room* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Room>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Room& from);
  void MergeFrom(const Room& 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(Room* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kRoomNumberFieldNumber = 1,
    kSipForwardingNumberFieldNumber = 2,
    kIsAnalogPhoneBlockedFieldNumber = 5,
    kAnalogPhoneCmsNumberFieldNumber = 3,
    kAnalogPhoneDigitalNumberFieldNumber = 4,
  };
  // string room_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_room_number() ;
  const std::string& room_number() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_room_number(Arg_&& arg, Args_... args);
  std::string* mutable_room_number();
  PROTOBUF_NODISCARD std::string* release_room_number();
  void set_allocated_room_number(std::string* ptr);

  private:
  const std::string& _internal_room_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_room_number(
      const std::string& value);
  std::string* _internal_mutable_room_number();

  public:
  // string sip_forwarding_number = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_sip_forwarding_number() ;
  const std::string& sip_forwarding_number() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_sip_forwarding_number(Arg_&& arg, Args_... args);
  std::string* mutable_sip_forwarding_number();
  PROTOBUF_NODISCARD std::string* release_sip_forwarding_number();
  void set_allocated_sip_forwarding_number(std::string* ptr);

  private:
  const std::string& _internal_sip_forwarding_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sip_forwarding_number(
      const std::string& value);
  std::string* _internal_mutable_sip_forwarding_number();

  public:
  // bool is_analog_phone_blocked = 5 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_is_analog_phone_blocked() ;
  bool is_analog_phone_blocked() const;
  void set_is_analog_phone_blocked(bool value);

  private:
  bool _internal_is_analog_phone_blocked() const;
  void _internal_set_is_analog_phone_blocked(bool value);

  public:
  // string analog_phone_cms_number = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  bool has_analog_phone_cms_number() const;
  void clear_analog_phone_cms_number() ;
  const std::string& analog_phone_cms_number() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_analog_phone_cms_number(Arg_&& arg, Args_... args);
  std::string* mutable_analog_phone_cms_number();
  PROTOBUF_NODISCARD std::string* release_analog_phone_cms_number();
  void set_allocated_analog_phone_cms_number(std::string* ptr);

  private:
  const std::string& _internal_analog_phone_cms_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_analog_phone_cms_number(
      const std::string& value);
  std::string* _internal_mutable_analog_phone_cms_number();

  public:
  // int32 analog_phone_digital_number = 4 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  bool has_analog_phone_digital_number() const;
  void clear_analog_phone_digital_number() ;
  ::int32_t analog_phone_digital_number() const;
  void set_analog_phone_digital_number(::int32_t value);

  private:
  ::int32_t _internal_analog_phone_digital_number() const;
  void _internal_set_analog_phone_digital_number(::int32_t value);

  public:
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.Room)
 private:
  class _Internal;
  void set_has_analog_phone_cms_number();
  void set_has_analog_phone_digital_number();

  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_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr room_number_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sip_forwarding_number_;
    bool is_analog_phone_blocked_;
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr analog_phone_cms_number_;
      ::int32_t analog_phone_digital_number_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline RoomFilter& operator=(const RoomFilter& from) {
    CopyFrom(from);
    return *this;
  }
  inline RoomFilter& operator=(RoomFilter&& 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 RoomFilter& default_instance() {
    return *internal_default_instance();
  }
  static inline const RoomFilter* internal_default_instance() {
    return reinterpret_cast<const RoomFilter*>(
               &_RoomFilter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(RoomFilter& a, RoomFilter& b) {
    a.Swap(&b);
  }
  inline void Swap(RoomFilter* 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(RoomFilter* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RoomFilter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RoomFilter>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const RoomFilter& from);
  void MergeFrom(const RoomFilter& 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(RoomFilter* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kRoomNumbersFieldNumber = 1,
  };
  // repeated string room_numbers = 1;
  int room_numbers_size() const;
  private:
  int _internal_room_numbers_size() const;

  public:
  void clear_room_numbers() ;
  const std::string& room_numbers(int index) const;
  std::string* mutable_room_numbers(int index);
  void set_room_numbers(int index, const std::string& value);
  void set_room_numbers(int index, std::string&& value);
  void set_room_numbers(int index, const char* value);
  void set_room_numbers(int index, const char* value, std::size_t size);
  void set_room_numbers(int index, absl::string_view value);
  std::string* add_room_numbers();
  void add_room_numbers(const std::string& value);
  void add_room_numbers(std::string&& value);
  void add_room_numbers(const char* value);
  void add_room_numbers(const char* value, std::size_t size);
  void add_room_numbers(absl::string_view value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& room_numbers() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_room_numbers();

  private:
  const std::string& _internal_room_numbers(int index) const;
  std::string* _internal_add_room_numbers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& _internal_room_numbers() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* _internal_mutable_room_numbers();

  public:
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.RoomFilter)
 private:
  class _Internal;

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

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

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

  inline RoomPaging& operator=(const RoomPaging& from) {
    CopyFrom(from);
    return *this;
  }
  inline RoomPaging& operator=(RoomPaging&& 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 RoomPaging& default_instance() {
    return *internal_default_instance();
  }
  static inline const RoomPaging* internal_default_instance() {
    return reinterpret_cast<const RoomPaging*>(
               &_RoomPaging_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(RoomPaging& a, RoomPaging& b) {
    a.Swap(&b);
  }
  inline void Swap(RoomPaging* 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(RoomPaging* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RoomPaging* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RoomPaging>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const RoomPaging& from);
  void MergeFrom(const RoomPaging& 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(RoomPaging* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kLimitFieldNumber = 1,
    kOffsetFieldNumber = 2,
  };
  // int32 limit = 1;
  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 = 2;
  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:deviceapis.device.v1.RoomPaging)
 private:
  class _Internal;

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

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

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

  inline SaveRoomListRequest& operator=(const SaveRoomListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline SaveRoomListRequest& operator=(SaveRoomListRequest&& 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 SaveRoomListRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const SaveRoomListRequest* internal_default_instance() {
    return reinterpret_cast<const SaveRoomListRequest*>(
               &_SaveRoomListRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(SaveRoomListRequest& a, SaveRoomListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(SaveRoomListRequest* 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(SaveRoomListRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SaveRoomListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SaveRoomListRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SaveRoomListRequest& from);
  void MergeFrom(const SaveRoomListRequest& 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(SaveRoomListRequest* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated .deviceapis.device.v1.Room data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;

  public:
  void clear_data() ;
  ::deviceapis::device::v1::Room* mutable_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >*
      mutable_data();
  private:
  const ::deviceapis::device::v1::Room& _internal_data(int index) const;
  ::deviceapis::device::v1::Room* _internal_add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>& _internal_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>* _internal_mutable_data();
  public:
  const ::deviceapis::device::v1::Room& data(int index) const;
  ::deviceapis::device::v1::Room* add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >&
      data() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRoomListRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room > data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

  inline SaveRoomListResponse_Error& operator=(const SaveRoomListResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline SaveRoomListResponse_Error& operator=(SaveRoomListResponse_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 SaveRoomListResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 2,
    REASON_NOT_SET = 0,
  };

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

  friend void swap(SaveRoomListResponse_Error& a, SaveRoomListResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(SaveRoomListResponse_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(SaveRoomListResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SaveRoomListResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SaveRoomListResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SaveRoomListResponse_Error& from);
  void MergeFrom(const SaveRoomListResponse_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(SaveRoomListResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.SaveRoomListResponse.Error";
  }
  protected:
  explicit SaveRoomListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kRoomNumberFieldNumber = 1,
    kValidationFieldNumber = 2,
  };
  // string room_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_room_number() ;
  const std::string& room_number() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_room_number(Arg_&& arg, Args_... args);
  std::string* mutable_room_number();
  PROTOBUF_NODISCARD std::string* release_room_number();
  void set_allocated_room_number(std::string* ptr);

  private:
  const std::string& _internal_room_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_room_number(
      const std::string& value);
  std::string* _internal_mutable_room_number();

  public:
  // .deviceapis.device.v1.ValidationError validation = 2;
  bool has_validation() const;
  private:
  bool _internal_has_validation() const;

  public:
  void clear_validation() ;
  const ::deviceapis::device::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::ValidationError* release_validation();
  ::deviceapis::device::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::deviceapis::device::v1::ValidationError* validation);
  private:
  const ::deviceapis::device::v1::ValidationError& _internal_validation() const;
  ::deviceapis::device::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::deviceapis::device::v1::ValidationError* validation);
  ::deviceapis::device::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRoomListResponse.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_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr room_number_;
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::deviceapis::device::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline SaveRoomListResponse& operator=(const SaveRoomListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline SaveRoomListResponse& operator=(SaveRoomListResponse&& 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 SaveRoomListResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const SaveRoomListResponse* internal_default_instance() {
    return reinterpret_cast<const SaveRoomListResponse*>(
               &_SaveRoomListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(SaveRoomListResponse& a, SaveRoomListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(SaveRoomListResponse* 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(SaveRoomListResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SaveRoomListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SaveRoomListResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SaveRoomListResponse& from);
  void MergeFrom(const SaveRoomListResponse& 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(SaveRoomListResponse* other);

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

  std::string GetTypeName() const final;

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

  typedef SaveRoomListResponse_Error Error;

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

  enum : int {
    kDataFieldNumber = 1,
    kErrorsFieldNumber = 2,
  };
  // repeated .deviceapis.device.v1.Room data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;

  public:
  void clear_data() ;
  ::deviceapis::device::v1::Room* mutable_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >*
      mutable_data();
  private:
  const ::deviceapis::device::v1::Room& _internal_data(int index) const;
  ::deviceapis::device::v1::Room* _internal_add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>& _internal_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>* _internal_mutable_data();
  public:
  const ::deviceapis::device::v1::Room& data(int index) const;
  ::deviceapis::device::v1::Room* add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >&
      data() const;
  // repeated .deviceapis.device.v1.SaveRoomListResponse.Error errors = 2;
  int errors_size() const;
  private:
  int _internal_errors_size() const;

  public:
  void clear_errors() ;
  ::deviceapis::device::v1::SaveRoomListResponse_Error* mutable_errors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::SaveRoomListResponse_Error >*
      mutable_errors();
  private:
  const ::deviceapis::device::v1::SaveRoomListResponse_Error& _internal_errors(int index) const;
  ::deviceapis::device::v1::SaveRoomListResponse_Error* _internal_add_errors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::SaveRoomListResponse_Error>& _internal_errors() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::SaveRoomListResponse_Error>* _internal_mutable_errors();
  public:
  const ::deviceapis::device::v1::SaveRoomListResponse_Error& errors(int index) const;
  ::deviceapis::device::v1::SaveRoomListResponse_Error* add_errors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::SaveRoomListResponse_Error >&
      errors() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRoomListResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room > data_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::SaveRoomListResponse_Error > errors_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

  inline SaveRoomRequest& operator=(const SaveRoomRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline SaveRoomRequest& operator=(SaveRoomRequest&& 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 SaveRoomRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const SaveRoomRequest* internal_default_instance() {
    return reinterpret_cast<const SaveRoomRequest*>(
               &_SaveRoomRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(SaveRoomRequest& a, SaveRoomRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(SaveRoomRequest* 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(SaveRoomRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SaveRoomRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SaveRoomRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SaveRoomRequest& from);
  void MergeFrom(const SaveRoomRequest& 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(SaveRoomRequest* other);

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // .deviceapis.device.v1.Room data = 1 [(.google.api.field_behavior) = REQUIRED];
  bool has_data() const;
  void clear_data() ;
  const ::deviceapis::device::v1::Room& data() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::Room* release_data();
  ::deviceapis::device::v1::Room* mutable_data();
  void set_allocated_data(::deviceapis::device::v1::Room* data);
  private:
  const ::deviceapis::device::v1::Room& _internal_data() const;
  ::deviceapis::device::v1::Room* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::deviceapis::device::v1::Room* data);
  ::deviceapis::device::v1::Room* unsafe_arena_release_data();
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRoomRequest)
 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_;
    ::deviceapis::device::v1::Room* data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

  inline SaveRoomResponse_Error& operator=(const SaveRoomResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline SaveRoomResponse_Error& operator=(SaveRoomResponse_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 SaveRoomResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

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

  friend void swap(SaveRoomResponse_Error& a, SaveRoomResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(SaveRoomResponse_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(SaveRoomResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SaveRoomResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SaveRoomResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SaveRoomResponse_Error& from);
  void MergeFrom(const SaveRoomResponse_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(SaveRoomResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.SaveRoomResponse.Error";
  }
  protected:
  explicit SaveRoomResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

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

  public:
  void clear_validation() ;
  const ::deviceapis::device::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::ValidationError* release_validation();
  ::deviceapis::device::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::deviceapis::device::v1::ValidationError* validation);
  private:
  const ::deviceapis::device::v1::ValidationError& _internal_validation() const;
  ::deviceapis::device::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::deviceapis::device::v1::ValidationError* validation);
  ::deviceapis::device::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRoomResponse.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_;
      ::deviceapis::device::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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

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

  inline SaveRoomResponse& operator=(const SaveRoomResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline SaveRoomResponse& operator=(SaveRoomResponse&& 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 SaveRoomResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    kError = 2,
    TYPE_NOT_SET = 0,
  };

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

  friend void swap(SaveRoomResponse& a, SaveRoomResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(SaveRoomResponse* 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(SaveRoomResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SaveRoomResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SaveRoomResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SaveRoomResponse& from);
  void MergeFrom(const SaveRoomResponse& 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(SaveRoomResponse* other);

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

  std::string GetTypeName() const final;

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

  typedef SaveRoomResponse_Error Error;

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

  enum : int {
    kDataFieldNumber = 1,
    kErrorFieldNumber = 2,
  };
  // .deviceapis.device.v1.Room data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::deviceapis::device::v1::Room& data() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::Room* release_data();
  ::deviceapis::device::v1::Room* mutable_data();
  void set_allocated_data(::deviceapis::device::v1::Room* data);
  private:
  const ::deviceapis::device::v1::Room& _internal_data() const;
  ::deviceapis::device::v1::Room* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::deviceapis::device::v1::Room* data);
  ::deviceapis::device::v1::Room* unsafe_arena_release_data();
  // .deviceapis.device.v1.SaveRoomResponse.Error error = 2;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::deviceapis::device::v1::SaveRoomResponse_Error& error() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::SaveRoomResponse_Error* release_error();
  ::deviceapis::device::v1::SaveRoomResponse_Error* mutable_error();
  void set_allocated_error(::deviceapis::device::v1::SaveRoomResponse_Error* error);
  private:
  const ::deviceapis::device::v1::SaveRoomResponse_Error& _internal_error() const;
  ::deviceapis::device::v1::SaveRoomResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::deviceapis::device::v1::SaveRoomResponse_Error* error);
  ::deviceapis::device::v1::SaveRoomResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRoomResponse)
 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_;
      ::deviceapis::device::v1::Room* data_;
      ::deviceapis::device::v1::SaveRoomResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

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

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




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


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

// DeleteRoomListRequest

// .deviceapis.device.v1.RoomFilter filter = 1;
inline bool DeleteRoomListRequest::has_filter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.filter_ != nullptr);
  return value;
}
inline void DeleteRoomListRequest::clear_filter() {
  if (_impl_.filter_ != nullptr) _impl_.filter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::deviceapis::device::v1::RoomFilter& DeleteRoomListRequest::_internal_filter() const {
  const ::deviceapis::device::v1::RoomFilter* p = _impl_.filter_;
  return p != nullptr ? *p : reinterpret_cast<const ::deviceapis::device::v1::RoomFilter&>(
      ::deviceapis::device::v1::_RoomFilter_default_instance_);
}
inline const ::deviceapis::device::v1::RoomFilter& DeleteRoomListRequest::filter() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRoomListRequest.filter)
  return _internal_filter();
}
inline void DeleteRoomListRequest::unsafe_arena_set_allocated_filter(
    ::deviceapis::device::v1::RoomFilter* 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:deviceapis.device.v1.DeleteRoomListRequest.filter)
}
inline ::deviceapis::device::v1::RoomFilter* DeleteRoomListRequest::release_filter() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::deviceapis::device::v1::RoomFilter* 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 ::deviceapis::device::v1::RoomFilter* DeleteRoomListRequest::unsafe_arena_release_filter() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.DeleteRoomListRequest.filter)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::deviceapis::device::v1::RoomFilter* temp = _impl_.filter_;
  _impl_.filter_ = nullptr;
  return temp;
}
inline ::deviceapis::device::v1::RoomFilter* DeleteRoomListRequest::_internal_mutable_filter() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.filter_ == nullptr) {
    auto* p = CreateMaybeMessage<::deviceapis::device::v1::RoomFilter>(GetArenaForAllocation());
    _impl_.filter_ = p;
  }
  return _impl_.filter_;
}
inline ::deviceapis::device::v1::RoomFilter* DeleteRoomListRequest::mutable_filter() {
  ::deviceapis::device::v1::RoomFilter* _msg = _internal_mutable_filter();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.DeleteRoomListRequest.filter)
  return _msg;
}
inline void DeleteRoomListRequest::set_allocated_filter(::deviceapis::device::v1::RoomFilter* 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:deviceapis.device.v1.DeleteRoomListRequest.filter)
}

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

// DeleteRoomListResponse_Error

// .deviceapis.device.v1.ValidationError validation = 1;
inline bool DeleteRoomListResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool DeleteRoomListResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void DeleteRoomListResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::deviceapis::device::v1::ValidationError* DeleteRoomListResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.DeleteRoomListResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::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 ::deviceapis::device::v1::ValidationError& DeleteRoomListResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::deviceapis::device::v1::ValidationError&>(::deviceapis::device::v1::_ValidationError_default_instance_);
}
inline const ::deviceapis::device::v1::ValidationError& DeleteRoomListResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRoomListResponse.Error.validation)
  return _internal_validation();
}
inline ::deviceapis::device::v1::ValidationError* DeleteRoomListResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.DeleteRoomListResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DeleteRoomListResponse_Error::unsafe_arena_set_allocated_validation(::deviceapis::device::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.DeleteRoomListResponse.Error.validation)
}
inline ::deviceapis::device::v1::ValidationError* DeleteRoomListResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::deviceapis::device::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::deviceapis::device::v1::ValidationError* DeleteRoomListResponse_Error::mutable_validation() {
  ::deviceapis::device::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.DeleteRoomListResponse.Error.validation)
  return _msg;
}

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

// DeleteRoomListResponse

// int32 data = 1;
inline bool DeleteRoomListResponse::has_data() const {
  return type_case() == kData;
}
inline void DeleteRoomListResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void DeleteRoomListResponse::clear_data() {
  if (type_case() == kData) {
    _impl_.type_.data_ = 0;
    clear_has_type();
  }
}
inline ::int32_t DeleteRoomListResponse::data() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRoomListResponse.data)
  return _internal_data();
}
inline void DeleteRoomListResponse::set_data(::int32_t value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.DeleteRoomListResponse.data)
}
inline ::int32_t DeleteRoomListResponse::_internal_data() const {
  if (type_case() == kData) {
    return _impl_.type_.data_;
  }
  return 0;
}
inline void DeleteRoomListResponse::_internal_set_data(::int32_t value) {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
  }
  _impl_.type_.data_ = value;
}

// .deviceapis.device.v1.DeleteRoomListResponse.Error error = 2;
inline bool DeleteRoomListResponse::has_error() const {
  return type_case() == kError;
}
inline bool DeleteRoomListResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void DeleteRoomListResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void DeleteRoomListResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::deviceapis::device::v1::DeleteRoomListResponse_Error* DeleteRoomListResponse::release_error() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.DeleteRoomListResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::deviceapis::device::v1::DeleteRoomListResponse_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 ::deviceapis::device::v1::DeleteRoomListResponse_Error& DeleteRoomListResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::deviceapis::device::v1::DeleteRoomListResponse_Error&>(::deviceapis::device::v1::_DeleteRoomListResponse_Error_default_instance_);
}
inline const ::deviceapis::device::v1::DeleteRoomListResponse_Error& DeleteRoomListResponse::error() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRoomListResponse.error)
  return _internal_error();
}
inline ::deviceapis::device::v1::DeleteRoomListResponse_Error* DeleteRoomListResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.DeleteRoomListResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::deviceapis::device::v1::DeleteRoomListResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DeleteRoomListResponse::unsafe_arena_set_allocated_error(::deviceapis::device::v1::DeleteRoomListResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.DeleteRoomListResponse.error)
}
inline ::deviceapis::device::v1::DeleteRoomListResponse_Error* DeleteRoomListResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::deviceapis::device::v1::DeleteRoomListResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::deviceapis::device::v1::DeleteRoomListResponse_Error* DeleteRoomListResponse::mutable_error() {
  ::deviceapis::device::v1::DeleteRoomListResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.DeleteRoomListResponse.error)
  return _msg;
}

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

// DeleteRoomRequest

// string room_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void DeleteRoomRequest::clear_room_number() {
  _impl_.room_number_.ClearToEmpty();
}
inline const std::string& DeleteRoomRequest::room_number() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRoomRequest.room_number)
  return _internal_room_number();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DeleteRoomRequest::set_room_number(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.room_number_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.DeleteRoomRequest.room_number)
}
inline std::string* DeleteRoomRequest::mutable_room_number() {
  std::string* _s = _internal_mutable_room_number();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.DeleteRoomRequest.room_number)
  return _s;
}
inline const std::string& DeleteRoomRequest::_internal_room_number() const {
  return _impl_.room_number_.Get();
}
inline void DeleteRoomRequest::_internal_set_room_number(const std::string& value) {
  ;


  _impl_.room_number_.Set(value, GetArenaForAllocation());
}
inline std::string* DeleteRoomRequest::_internal_mutable_room_number() {
  ;
  return _impl_.room_number_.Mutable( GetArenaForAllocation());
}
inline std::string* DeleteRoomRequest::release_room_number() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.DeleteRoomRequest.room_number)
  return _impl_.room_number_.Release();
}
inline void DeleteRoomRequest::set_allocated_room_number(std::string* value) {
  _impl_.room_number_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.room_number_.IsDefault()) {
          _impl_.room_number_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.DeleteRoomRequest.room_number)
}

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

// DeleteRoomResponse_Error

// .deviceapis.device.v1.ValidationError validation = 1;
inline bool DeleteRoomResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool DeleteRoomResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void DeleteRoomResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::deviceapis::device::v1::ValidationError* DeleteRoomResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.DeleteRoomResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::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 ::deviceapis::device::v1::ValidationError& DeleteRoomResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::deviceapis::device::v1::ValidationError&>(::deviceapis::device::v1::_ValidationError_default_instance_);
}
inline const ::deviceapis::device::v1::ValidationError& DeleteRoomResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRoomResponse.Error.validation)
  return _internal_validation();
}
inline ::deviceapis::device::v1::ValidationError* DeleteRoomResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.DeleteRoomResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DeleteRoomResponse_Error::unsafe_arena_set_allocated_validation(::deviceapis::device::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.DeleteRoomResponse.Error.validation)
}
inline ::deviceapis::device::v1::ValidationError* DeleteRoomResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::deviceapis::device::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::deviceapis::device::v1::ValidationError* DeleteRoomResponse_Error::mutable_validation() {
  ::deviceapis::device::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.DeleteRoomResponse.Error.validation)
  return _msg;
}

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

// DeleteRoomResponse

// .deviceapis.device.v1.DeleteRoomResponse.Error error = 1;
inline bool DeleteRoomResponse::has_error() const {
  return type_case() == kError;
}
inline bool DeleteRoomResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void DeleteRoomResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void DeleteRoomResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::deviceapis::device::v1::DeleteRoomResponse_Error* DeleteRoomResponse::release_error() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.DeleteRoomResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::deviceapis::device::v1::DeleteRoomResponse_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 ::deviceapis::device::v1::DeleteRoomResponse_Error& DeleteRoomResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::deviceapis::device::v1::DeleteRoomResponse_Error&>(::deviceapis::device::v1::_DeleteRoomResponse_Error_default_instance_);
}
inline const ::deviceapis::device::v1::DeleteRoomResponse_Error& DeleteRoomResponse::error() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRoomResponse.error)
  return _internal_error();
}
inline ::deviceapis::device::v1::DeleteRoomResponse_Error* DeleteRoomResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.DeleteRoomResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::deviceapis::device::v1::DeleteRoomResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DeleteRoomResponse::unsafe_arena_set_allocated_error(::deviceapis::device::v1::DeleteRoomResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.DeleteRoomResponse.error)
}
inline ::deviceapis::device::v1::DeleteRoomResponse_Error* DeleteRoomResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::deviceapis::device::v1::DeleteRoomResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::deviceapis::device::v1::DeleteRoomResponse_Error* DeleteRoomResponse::mutable_error() {
  ::deviceapis::device::v1::DeleteRoomResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.DeleteRoomResponse.error)
  return _msg;
}

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

// GetRoomCountRequest

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

// GetRoomCountResponse

// int32 data = 1;
inline bool GetRoomCountResponse::has_data() const {
  return type_case() == kData;
}
inline void GetRoomCountResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void GetRoomCountResponse::clear_data() {
  if (type_case() == kData) {
    _impl_.type_.data_ = 0;
    clear_has_type();
  }
}
inline ::int32_t GetRoomCountResponse::data() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.GetRoomCountResponse.data)
  return _internal_data();
}
inline void GetRoomCountResponse::set_data(::int32_t value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.GetRoomCountResponse.data)
}
inline ::int32_t GetRoomCountResponse::_internal_data() const {
  if (type_case() == kData) {
    return _impl_.type_.data_;
  }
  return 0;
}
inline void GetRoomCountResponse::_internal_set_data(::int32_t value) {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
  }
  _impl_.type_.data_ = value;
}

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

// GetRoomListRequest

// .deviceapis.device.v1.RoomPaging paging = 1;
inline bool GetRoomListRequest::has_paging() const {
  return pagination_case() == kPaging;
}
inline bool GetRoomListRequest::_internal_has_paging() const {
  return pagination_case() == kPaging;
}
inline void GetRoomListRequest::set_has_paging() {
  _impl_._oneof_case_[0] = kPaging;
}
inline void GetRoomListRequest::clear_paging() {
  if (pagination_case() == kPaging) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.pagination_.paging_;
    }
    clear_has_pagination();
  }
}
inline ::deviceapis::device::v1::RoomPaging* GetRoomListRequest::release_paging() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.GetRoomListRequest.paging)
  if (pagination_case() == kPaging) {
    clear_has_pagination();
    ::deviceapis::device::v1::RoomPaging* 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 ::deviceapis::device::v1::RoomPaging& GetRoomListRequest::_internal_paging() const {
  return pagination_case() == kPaging
      ? *_impl_.pagination_.paging_
      : reinterpret_cast<::deviceapis::device::v1::RoomPaging&>(::deviceapis::device::v1::_RoomPaging_default_instance_);
}
inline const ::deviceapis::device::v1::RoomPaging& GetRoomListRequest::paging() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.GetRoomListRequest.paging)
  return _internal_paging();
}
inline ::deviceapis::device::v1::RoomPaging* GetRoomListRequest::unsafe_arena_release_paging() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.GetRoomListRequest.paging)
  if (pagination_case() == kPaging) {
    clear_has_pagination();
    ::deviceapis::device::v1::RoomPaging* temp = _impl_.pagination_.paging_;
    _impl_.pagination_.paging_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetRoomListRequest::unsafe_arena_set_allocated_paging(::deviceapis::device::v1::RoomPaging* paging) {
  clear_pagination();
  if (paging) {
    set_has_paging();
    _impl_.pagination_.paging_ = paging;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.GetRoomListRequest.paging)
}
inline ::deviceapis::device::v1::RoomPaging* GetRoomListRequest::_internal_mutable_paging() {
  if (pagination_case() != kPaging) {
    clear_pagination();
    set_has_paging();
    _impl_.pagination_.paging_ = CreateMaybeMessage< ::deviceapis::device::v1::RoomPaging >(GetArenaForAllocation());
  }
  return _impl_.pagination_.paging_;
}
inline ::deviceapis::device::v1::RoomPaging* GetRoomListRequest::mutable_paging() {
  ::deviceapis::device::v1::RoomPaging* _msg = _internal_mutable_paging();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.GetRoomListRequest.paging)
  return _msg;
}

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

// GetRoomListResponse

// repeated .deviceapis.device.v1.Room data = 1;
inline int GetRoomListResponse::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int GetRoomListResponse::data_size() const {
  return _internal_data_size();
}
inline void GetRoomListResponse::clear_data() {
  _internal_mutable_data()->Clear();
}
inline ::deviceapis::device::v1::Room* GetRoomListResponse::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.GetRoomListResponse.data)
  return _internal_mutable_data()->Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >*
GetRoomListResponse::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:deviceapis.device.v1.GetRoomListResponse.data)
  return _internal_mutable_data();
}
inline const ::deviceapis::device::v1::Room& GetRoomListResponse::_internal_data(int index) const {
  return _internal_data().Get(index);
}
inline const ::deviceapis::device::v1::Room& GetRoomListResponse::data(int index) const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.GetRoomListResponse.data)
  return _internal_data(index);
}
inline ::deviceapis::device::v1::Room* GetRoomListResponse::_internal_add_data() {
  return _internal_mutable_data()->Add();
}
inline ::deviceapis::device::v1::Room* GetRoomListResponse::add_data() {
  ::deviceapis::device::v1::Room* _add = _internal_add_data();
  // @@protoc_insertion_point(field_add:deviceapis.device.v1.GetRoomListResponse.data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >&
GetRoomListResponse::data() const {
  // @@protoc_insertion_point(field_list:deviceapis.device.v1.GetRoomListResponse.data)
  return _internal_data();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>&
GetRoomListResponse::_internal_data() const {
  return _impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>*
GetRoomListResponse::_internal_mutable_data() {
  return &_impl_.data_;
}

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

// GetRoomRequest

// string room_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void GetRoomRequest::clear_room_number() {
  _impl_.room_number_.ClearToEmpty();
}
inline const std::string& GetRoomRequest::room_number() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.GetRoomRequest.room_number)
  return _internal_room_number();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GetRoomRequest::set_room_number(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.room_number_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.GetRoomRequest.room_number)
}
inline std::string* GetRoomRequest::mutable_room_number() {
  std::string* _s = _internal_mutable_room_number();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.GetRoomRequest.room_number)
  return _s;
}
inline const std::string& GetRoomRequest::_internal_room_number() const {
  return _impl_.room_number_.Get();
}
inline void GetRoomRequest::_internal_set_room_number(const std::string& value) {
  ;


  _impl_.room_number_.Set(value, GetArenaForAllocation());
}
inline std::string* GetRoomRequest::_internal_mutable_room_number() {
  ;
  return _impl_.room_number_.Mutable( GetArenaForAllocation());
}
inline std::string* GetRoomRequest::release_room_number() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.GetRoomRequest.room_number)
  return _impl_.room_number_.Release();
}
inline void GetRoomRequest::set_allocated_room_number(std::string* value) {
  _impl_.room_number_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.room_number_.IsDefault()) {
          _impl_.room_number_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.GetRoomRequest.room_number)
}

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

// GetRoomResponse

// .deviceapis.device.v1.Room data = 1;
inline bool GetRoomResponse::has_data() const {
  return type_case() == kData;
}
inline bool GetRoomResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void GetRoomResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void GetRoomResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::deviceapis::device::v1::Room* GetRoomResponse::release_data() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.GetRoomResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::deviceapis::device::v1::Room* 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 ::deviceapis::device::v1::Room& GetRoomResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::deviceapis::device::v1::Room&>(::deviceapis::device::v1::_Room_default_instance_);
}
inline const ::deviceapis::device::v1::Room& GetRoomResponse::data() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.GetRoomResponse.data)
  return _internal_data();
}
inline ::deviceapis::device::v1::Room* GetRoomResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.GetRoomResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::deviceapis::device::v1::Room* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetRoomResponse::unsafe_arena_set_allocated_data(::deviceapis::device::v1::Room* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.GetRoomResponse.data)
}
inline ::deviceapis::device::v1::Room* GetRoomResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::deviceapis::device::v1::Room >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::deviceapis::device::v1::Room* GetRoomResponse::mutable_data() {
  ::deviceapis::device::v1::Room* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.GetRoomResponse.data)
  return _msg;
}

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

// Room

// string room_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void Room::clear_room_number() {
  _impl_.room_number_.ClearToEmpty();
}
inline const std::string& Room::room_number() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Room.room_number)
  return _internal_room_number();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Room::set_room_number(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.room_number_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.Room.room_number)
}
inline std::string* Room::mutable_room_number() {
  std::string* _s = _internal_mutable_room_number();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.Room.room_number)
  return _s;
}
inline const std::string& Room::_internal_room_number() const {
  return _impl_.room_number_.Get();
}
inline void Room::_internal_set_room_number(const std::string& value) {
  ;


  _impl_.room_number_.Set(value, GetArenaForAllocation());
}
inline std::string* Room::_internal_mutable_room_number() {
  ;
  return _impl_.room_number_.Mutable( GetArenaForAllocation());
}
inline std::string* Room::release_room_number() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.Room.room_number)
  return _impl_.room_number_.Release();
}
inline void Room::set_allocated_room_number(std::string* value) {
  _impl_.room_number_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.room_number_.IsDefault()) {
          _impl_.room_number_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.Room.room_number)
}

// string sip_forwarding_number = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void Room::clear_sip_forwarding_number() {
  _impl_.sip_forwarding_number_.ClearToEmpty();
}
inline const std::string& Room::sip_forwarding_number() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Room.sip_forwarding_number)
  return _internal_sip_forwarding_number();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Room::set_sip_forwarding_number(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.sip_forwarding_number_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.Room.sip_forwarding_number)
}
inline std::string* Room::mutable_sip_forwarding_number() {
  std::string* _s = _internal_mutable_sip_forwarding_number();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.Room.sip_forwarding_number)
  return _s;
}
inline const std::string& Room::_internal_sip_forwarding_number() const {
  return _impl_.sip_forwarding_number_.Get();
}
inline void Room::_internal_set_sip_forwarding_number(const std::string& value) {
  ;


  _impl_.sip_forwarding_number_.Set(value, GetArenaForAllocation());
}
inline std::string* Room::_internal_mutable_sip_forwarding_number() {
  ;
  return _impl_.sip_forwarding_number_.Mutable( GetArenaForAllocation());
}
inline std::string* Room::release_sip_forwarding_number() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.Room.sip_forwarding_number)
  return _impl_.sip_forwarding_number_.Release();
}
inline void Room::set_allocated_sip_forwarding_number(std::string* value) {
  _impl_.sip_forwarding_number_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.sip_forwarding_number_.IsDefault()) {
          _impl_.sip_forwarding_number_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.Room.sip_forwarding_number)
}

// string analog_phone_cms_number = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline bool Room::has_analog_phone_cms_number() const {
  return type_case() == kAnalogPhoneCmsNumber;
}
inline void Room::set_has_analog_phone_cms_number() {
  _impl_._oneof_case_[0] = kAnalogPhoneCmsNumber;
}
inline void Room::clear_analog_phone_cms_number() {
  if (type_case() == kAnalogPhoneCmsNumber) {
    _impl_.type_.analog_phone_cms_number_.Destroy();
    clear_has_type();
  }
}
inline const std::string& Room::analog_phone_cms_number() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Room.analog_phone_cms_number)
  return _internal_analog_phone_cms_number();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Room::set_analog_phone_cms_number(Arg_&& arg,
                                                     Args_... args) {
  if (type_case() != kAnalogPhoneCmsNumber) {
    clear_type();

    set_has_analog_phone_cms_number();
    _impl_.type_.analog_phone_cms_number_.InitDefault();
  }
  _impl_.type_.analog_phone_cms_number_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.Room.analog_phone_cms_number)
}
inline std::string* Room::mutable_analog_phone_cms_number() {
  std::string* _s = _internal_mutable_analog_phone_cms_number();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.Room.analog_phone_cms_number)
  return _s;
}
inline const std::string& Room::_internal_analog_phone_cms_number() const {
  if (type_case() != kAnalogPhoneCmsNumber) {
    return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.type_.analog_phone_cms_number_.Get();
}
inline void Room::_internal_set_analog_phone_cms_number(const std::string& value) {
  if (type_case() != kAnalogPhoneCmsNumber) {
    clear_type();

    set_has_analog_phone_cms_number();
    _impl_.type_.analog_phone_cms_number_.InitDefault();
  }


  _impl_.type_.analog_phone_cms_number_.Set(value, GetArenaForAllocation());
}
inline std::string* Room::_internal_mutable_analog_phone_cms_number() {
  if (type_case() != kAnalogPhoneCmsNumber) {
    clear_type();

    set_has_analog_phone_cms_number();
    _impl_.type_.analog_phone_cms_number_.InitDefault();
  }
  return _impl_.type_.analog_phone_cms_number_.Mutable( GetArenaForAllocation());
}
inline std::string* Room::release_analog_phone_cms_number() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.Room.analog_phone_cms_number)
  if (type_case() != kAnalogPhoneCmsNumber) {
    return nullptr;
  }
  clear_has_type();
  return _impl_.type_.analog_phone_cms_number_.Release();
}
inline void Room::set_allocated_analog_phone_cms_number(std::string* value) {
  if (has_type()) {
    clear_type();
  }
  if (value != nullptr) {
    set_has_analog_phone_cms_number();
    _impl_.type_.analog_phone_cms_number_.InitAllocated(value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.Room.analog_phone_cms_number)
}

// int32 analog_phone_digital_number = 4 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline bool Room::has_analog_phone_digital_number() const {
  return type_case() == kAnalogPhoneDigitalNumber;
}
inline void Room::set_has_analog_phone_digital_number() {
  _impl_._oneof_case_[0] = kAnalogPhoneDigitalNumber;
}
inline void Room::clear_analog_phone_digital_number() {
  if (type_case() == kAnalogPhoneDigitalNumber) {
    _impl_.type_.analog_phone_digital_number_ = 0;
    clear_has_type();
  }
}
inline ::int32_t Room::analog_phone_digital_number() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Room.analog_phone_digital_number)
  return _internal_analog_phone_digital_number();
}
inline void Room::set_analog_phone_digital_number(::int32_t value) {
  _internal_set_analog_phone_digital_number(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.Room.analog_phone_digital_number)
}
inline ::int32_t Room::_internal_analog_phone_digital_number() const {
  if (type_case() == kAnalogPhoneDigitalNumber) {
    return _impl_.type_.analog_phone_digital_number_;
  }
  return 0;
}
inline void Room::_internal_set_analog_phone_digital_number(::int32_t value) {
  if (type_case() != kAnalogPhoneDigitalNumber) {
    clear_type();
    set_has_analog_phone_digital_number();
  }
  _impl_.type_.analog_phone_digital_number_ = value;
}

// bool is_analog_phone_blocked = 5 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void Room::clear_is_analog_phone_blocked() {
  _impl_.is_analog_phone_blocked_ = false;
}
inline bool Room::is_analog_phone_blocked() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Room.is_analog_phone_blocked)
  return _internal_is_analog_phone_blocked();
}
inline void Room::set_is_analog_phone_blocked(bool value) {
  _internal_set_is_analog_phone_blocked(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.Room.is_analog_phone_blocked)
}
inline bool Room::_internal_is_analog_phone_blocked() const {
  return _impl_.is_analog_phone_blocked_;
}
inline void Room::_internal_set_is_analog_phone_blocked(bool value) {
  ;
  _impl_.is_analog_phone_blocked_ = value;
}

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

// RoomFilter

// repeated string room_numbers = 1;
inline int RoomFilter::_internal_room_numbers_size() const {
  return _impl_.room_numbers_.size();
}
inline int RoomFilter::room_numbers_size() const {
  return _internal_room_numbers_size();
}
inline void RoomFilter::clear_room_numbers() {
  _internal_mutable_room_numbers()->Clear();
}
inline std::string* RoomFilter::add_room_numbers() {
  std::string* _s = _internal_add_room_numbers();
  // @@protoc_insertion_point(field_add_mutable:deviceapis.device.v1.RoomFilter.room_numbers)
  return _s;
}
inline const std::string& RoomFilter::room_numbers(int index) const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.RoomFilter.room_numbers)
  return _internal_room_numbers(index);
}
inline std::string* RoomFilter::mutable_room_numbers(int index) {
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.RoomFilter.room_numbers)
  return _internal_mutable_room_numbers()->Mutable(index);
}
inline void RoomFilter::set_room_numbers(int index, const std::string& value) {
  _internal_mutable_room_numbers()->Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::set_room_numbers(int index, std::string&& value) {
  _internal_mutable_room_numbers()->Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::set_room_numbers(int index, const char* value) {
  ABSL_DCHECK(value != nullptr);
  _internal_mutable_room_numbers()->Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::set_room_numbers(int index, const char* value,
                              std::size_t size) {
  _internal_mutable_room_numbers()->Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::set_room_numbers(int index, absl::string_view value) {
  _internal_mutable_room_numbers()->Mutable(index)->assign(value.data(),
                                                     value.size());
  // @@protoc_insertion_point(field_set_string_piece:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::add_room_numbers(const std::string& value) {
  _internal_mutable_room_numbers()->Add()->assign(value);
  // @@protoc_insertion_point(field_add:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::add_room_numbers(std::string&& value) {
  _internal_mutable_room_numbers()->Add(std::move(value));
  // @@protoc_insertion_point(field_add:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::add_room_numbers(const char* value) {
  ABSL_DCHECK(value != nullptr);
  _internal_mutable_room_numbers()->Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::add_room_numbers(const char* value, std::size_t size) {
  _internal_mutable_room_numbers()->Add()->assign(
      reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline void RoomFilter::add_room_numbers(absl::string_view value) {
  _internal_mutable_room_numbers()->Add()->assign(value.data(), value.size());
  // @@protoc_insertion_point(field_add_string_piece:deviceapis.device.v1.RoomFilter.room_numbers)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
RoomFilter::room_numbers() const {
  // @@protoc_insertion_point(field_list:deviceapis.device.v1.RoomFilter.room_numbers)
  return _internal_room_numbers();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* RoomFilter::mutable_room_numbers() {
  // @@protoc_insertion_point(field_mutable_list:deviceapis.device.v1.RoomFilter.room_numbers)
  return _internal_mutable_room_numbers();
}
inline const std::string& RoomFilter::_internal_room_numbers(int index) const {
  return _internal_room_numbers().Get(index);
}
inline std::string* RoomFilter::_internal_add_room_numbers() {
  return _internal_mutable_room_numbers()->Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
RoomFilter::_internal_room_numbers() const {
  return _impl_.room_numbers_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
RoomFilter::_internal_mutable_room_numbers() {
  return &_impl_.room_numbers_;
}

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

// RoomPaging

// int32 limit = 1;
inline void RoomPaging::clear_limit() {
  _impl_.limit_ = 0;
}
inline ::int32_t RoomPaging::limit() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.RoomPaging.limit)
  return _internal_limit();
}
inline void RoomPaging::set_limit(::int32_t value) {
  _internal_set_limit(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.RoomPaging.limit)
}
inline ::int32_t RoomPaging::_internal_limit() const {
  return _impl_.limit_;
}
inline void RoomPaging::_internal_set_limit(::int32_t value) {
  ;
  _impl_.limit_ = value;
}

// int32 offset = 2;
inline void RoomPaging::clear_offset() {
  _impl_.offset_ = 0;
}
inline ::int32_t RoomPaging::offset() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.RoomPaging.offset)
  return _internal_offset();
}
inline void RoomPaging::set_offset(::int32_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.RoomPaging.offset)
}
inline ::int32_t RoomPaging::_internal_offset() const {
  return _impl_.offset_;
}
inline void RoomPaging::_internal_set_offset(::int32_t value) {
  ;
  _impl_.offset_ = value;
}

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

// SaveRoomListRequest

// repeated .deviceapis.device.v1.Room data = 1;
inline int SaveRoomListRequest::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int SaveRoomListRequest::data_size() const {
  return _internal_data_size();
}
inline void SaveRoomListRequest::clear_data() {
  _internal_mutable_data()->Clear();
}
inline ::deviceapis::device::v1::Room* SaveRoomListRequest::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomListRequest.data)
  return _internal_mutable_data()->Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >*
SaveRoomListRequest::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:deviceapis.device.v1.SaveRoomListRequest.data)
  return _internal_mutable_data();
}
inline const ::deviceapis::device::v1::Room& SaveRoomListRequest::_internal_data(int index) const {
  return _internal_data().Get(index);
}
inline const ::deviceapis::device::v1::Room& SaveRoomListRequest::data(int index) const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomListRequest.data)
  return _internal_data(index);
}
inline ::deviceapis::device::v1::Room* SaveRoomListRequest::_internal_add_data() {
  return _internal_mutable_data()->Add();
}
inline ::deviceapis::device::v1::Room* SaveRoomListRequest::add_data() {
  ::deviceapis::device::v1::Room* _add = _internal_add_data();
  // @@protoc_insertion_point(field_add:deviceapis.device.v1.SaveRoomListRequest.data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >&
SaveRoomListRequest::data() const {
  // @@protoc_insertion_point(field_list:deviceapis.device.v1.SaveRoomListRequest.data)
  return _internal_data();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>&
SaveRoomListRequest::_internal_data() const {
  return _impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>*
SaveRoomListRequest::_internal_mutable_data() {
  return &_impl_.data_;
}

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

// SaveRoomListResponse_Error

// string room_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void SaveRoomListResponse_Error::clear_room_number() {
  _impl_.room_number_.ClearToEmpty();
}
inline const std::string& SaveRoomListResponse_Error::room_number() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomListResponse.Error.room_number)
  return _internal_room_number();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void SaveRoomListResponse_Error::set_room_number(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.room_number_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.SaveRoomListResponse.Error.room_number)
}
inline std::string* SaveRoomListResponse_Error::mutable_room_number() {
  std::string* _s = _internal_mutable_room_number();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomListResponse.Error.room_number)
  return _s;
}
inline const std::string& SaveRoomListResponse_Error::_internal_room_number() const {
  return _impl_.room_number_.Get();
}
inline void SaveRoomListResponse_Error::_internal_set_room_number(const std::string& value) {
  ;


  _impl_.room_number_.Set(value, GetArenaForAllocation());
}
inline std::string* SaveRoomListResponse_Error::_internal_mutable_room_number() {
  ;
  return _impl_.room_number_.Mutable( GetArenaForAllocation());
}
inline std::string* SaveRoomListResponse_Error::release_room_number() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRoomListResponse.Error.room_number)
  return _impl_.room_number_.Release();
}
inline void SaveRoomListResponse_Error::set_allocated_room_number(std::string* value) {
  _impl_.room_number_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.room_number_.IsDefault()) {
          _impl_.room_number_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.SaveRoomListResponse.Error.room_number)
}

// .deviceapis.device.v1.ValidationError validation = 2;
inline bool SaveRoomListResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool SaveRoomListResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void SaveRoomListResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::deviceapis::device::v1::ValidationError* SaveRoomListResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRoomListResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::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 ::deviceapis::device::v1::ValidationError& SaveRoomListResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::deviceapis::device::v1::ValidationError&>(::deviceapis::device::v1::_ValidationError_default_instance_);
}
inline const ::deviceapis::device::v1::ValidationError& SaveRoomListResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomListResponse.Error.validation)
  return _internal_validation();
}
inline ::deviceapis::device::v1::ValidationError* SaveRoomListResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.SaveRoomListResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SaveRoomListResponse_Error::unsafe_arena_set_allocated_validation(::deviceapis::device::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.SaveRoomListResponse.Error.validation)
}
inline ::deviceapis::device::v1::ValidationError* SaveRoomListResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::deviceapis::device::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::deviceapis::device::v1::ValidationError* SaveRoomListResponse_Error::mutable_validation() {
  ::deviceapis::device::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomListResponse.Error.validation)
  return _msg;
}

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

// SaveRoomListResponse

// repeated .deviceapis.device.v1.Room data = 1;
inline int SaveRoomListResponse::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int SaveRoomListResponse::data_size() const {
  return _internal_data_size();
}
inline void SaveRoomListResponse::clear_data() {
  _internal_mutable_data()->Clear();
}
inline ::deviceapis::device::v1::Room* SaveRoomListResponse::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomListResponse.data)
  return _internal_mutable_data()->Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >*
SaveRoomListResponse::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:deviceapis.device.v1.SaveRoomListResponse.data)
  return _internal_mutable_data();
}
inline const ::deviceapis::device::v1::Room& SaveRoomListResponse::_internal_data(int index) const {
  return _internal_data().Get(index);
}
inline const ::deviceapis::device::v1::Room& SaveRoomListResponse::data(int index) const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomListResponse.data)
  return _internal_data(index);
}
inline ::deviceapis::device::v1::Room* SaveRoomListResponse::_internal_add_data() {
  return _internal_mutable_data()->Add();
}
inline ::deviceapis::device::v1::Room* SaveRoomListResponse::add_data() {
  ::deviceapis::device::v1::Room* _add = _internal_add_data();
  // @@protoc_insertion_point(field_add:deviceapis.device.v1.SaveRoomListResponse.data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Room >&
SaveRoomListResponse::data() const {
  // @@protoc_insertion_point(field_list:deviceapis.device.v1.SaveRoomListResponse.data)
  return _internal_data();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>&
SaveRoomListResponse::_internal_data() const {
  return _impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Room>*
SaveRoomListResponse::_internal_mutable_data() {
  return &_impl_.data_;
}

// repeated .deviceapis.device.v1.SaveRoomListResponse.Error errors = 2;
inline int SaveRoomListResponse::_internal_errors_size() const {
  return _impl_.errors_.size();
}
inline int SaveRoomListResponse::errors_size() const {
  return _internal_errors_size();
}
inline void SaveRoomListResponse::clear_errors() {
  _internal_mutable_errors()->Clear();
}
inline ::deviceapis::device::v1::SaveRoomListResponse_Error* SaveRoomListResponse::mutable_errors(int index) {
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomListResponse.errors)
  return _internal_mutable_errors()->Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::SaveRoomListResponse_Error >*
SaveRoomListResponse::mutable_errors() {
  // @@protoc_insertion_point(field_mutable_list:deviceapis.device.v1.SaveRoomListResponse.errors)
  return _internal_mutable_errors();
}
inline const ::deviceapis::device::v1::SaveRoomListResponse_Error& SaveRoomListResponse::_internal_errors(int index) const {
  return _internal_errors().Get(index);
}
inline const ::deviceapis::device::v1::SaveRoomListResponse_Error& SaveRoomListResponse::errors(int index) const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomListResponse.errors)
  return _internal_errors(index);
}
inline ::deviceapis::device::v1::SaveRoomListResponse_Error* SaveRoomListResponse::_internal_add_errors() {
  return _internal_mutable_errors()->Add();
}
inline ::deviceapis::device::v1::SaveRoomListResponse_Error* SaveRoomListResponse::add_errors() {
  ::deviceapis::device::v1::SaveRoomListResponse_Error* _add = _internal_add_errors();
  // @@protoc_insertion_point(field_add:deviceapis.device.v1.SaveRoomListResponse.errors)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::SaveRoomListResponse_Error >&
SaveRoomListResponse::errors() const {
  // @@protoc_insertion_point(field_list:deviceapis.device.v1.SaveRoomListResponse.errors)
  return _internal_errors();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::SaveRoomListResponse_Error>&
SaveRoomListResponse::_internal_errors() const {
  return _impl_.errors_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::SaveRoomListResponse_Error>*
SaveRoomListResponse::_internal_mutable_errors() {
  return &_impl_.errors_;
}

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

// SaveRoomRequest

// .deviceapis.device.v1.Room data = 1 [(.google.api.field_behavior) = REQUIRED];
inline bool SaveRoomRequest::has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr);
  return value;
}
inline void SaveRoomRequest::clear_data() {
  if (_impl_.data_ != nullptr) _impl_.data_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::deviceapis::device::v1::Room& SaveRoomRequest::_internal_data() const {
  const ::deviceapis::device::v1::Room* p = _impl_.data_;
  return p != nullptr ? *p : reinterpret_cast<const ::deviceapis::device::v1::Room&>(
      ::deviceapis::device::v1::_Room_default_instance_);
}
inline const ::deviceapis::device::v1::Room& SaveRoomRequest::data() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomRequest.data)
  return _internal_data();
}
inline void SaveRoomRequest::unsafe_arena_set_allocated_data(
    ::deviceapis::device::v1::Room* 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:deviceapis.device.v1.SaveRoomRequest.data)
}
inline ::deviceapis::device::v1::Room* SaveRoomRequest::release_data() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::deviceapis::device::v1::Room* 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 ::deviceapis::device::v1::Room* SaveRoomRequest::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRoomRequest.data)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::deviceapis::device::v1::Room* temp = _impl_.data_;
  _impl_.data_ = nullptr;
  return temp;
}
inline ::deviceapis::device::v1::Room* SaveRoomRequest::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.data_ == nullptr) {
    auto* p = CreateMaybeMessage<::deviceapis::device::v1::Room>(GetArenaForAllocation());
    _impl_.data_ = p;
  }
  return _impl_.data_;
}
inline ::deviceapis::device::v1::Room* SaveRoomRequest::mutable_data() {
  ::deviceapis::device::v1::Room* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomRequest.data)
  return _msg;
}
inline void SaveRoomRequest::set_allocated_data(::deviceapis::device::v1::Room* 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:deviceapis.device.v1.SaveRoomRequest.data)
}

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

// SaveRoomResponse_Error

// .deviceapis.device.v1.ValidationError validation = 1;
inline bool SaveRoomResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool SaveRoomResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void SaveRoomResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::deviceapis::device::v1::ValidationError* SaveRoomResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRoomResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::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 ::deviceapis::device::v1::ValidationError& SaveRoomResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::deviceapis::device::v1::ValidationError&>(::deviceapis::device::v1::_ValidationError_default_instance_);
}
inline const ::deviceapis::device::v1::ValidationError& SaveRoomResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomResponse.Error.validation)
  return _internal_validation();
}
inline ::deviceapis::device::v1::ValidationError* SaveRoomResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.SaveRoomResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SaveRoomResponse_Error::unsafe_arena_set_allocated_validation(::deviceapis::device::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.SaveRoomResponse.Error.validation)
}
inline ::deviceapis::device::v1::ValidationError* SaveRoomResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::deviceapis::device::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::deviceapis::device::v1::ValidationError* SaveRoomResponse_Error::mutable_validation() {
  ::deviceapis::device::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomResponse.Error.validation)
  return _msg;
}

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

// SaveRoomResponse

// .deviceapis.device.v1.Room data = 1;
inline bool SaveRoomResponse::has_data() const {
  return type_case() == kData;
}
inline bool SaveRoomResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void SaveRoomResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void SaveRoomResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::deviceapis::device::v1::Room* SaveRoomResponse::release_data() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRoomResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::deviceapis::device::v1::Room* 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 ::deviceapis::device::v1::Room& SaveRoomResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::deviceapis::device::v1::Room&>(::deviceapis::device::v1::_Room_default_instance_);
}
inline const ::deviceapis::device::v1::Room& SaveRoomResponse::data() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomResponse.data)
  return _internal_data();
}
inline ::deviceapis::device::v1::Room* SaveRoomResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.SaveRoomResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::deviceapis::device::v1::Room* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SaveRoomResponse::unsafe_arena_set_allocated_data(::deviceapis::device::v1::Room* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.SaveRoomResponse.data)
}
inline ::deviceapis::device::v1::Room* SaveRoomResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::deviceapis::device::v1::Room >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::deviceapis::device::v1::Room* SaveRoomResponse::mutable_data() {
  ::deviceapis::device::v1::Room* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomResponse.data)
  return _msg;
}

// .deviceapis.device.v1.SaveRoomResponse.Error error = 2;
inline bool SaveRoomResponse::has_error() const {
  return type_case() == kError;
}
inline bool SaveRoomResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void SaveRoomResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void SaveRoomResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::deviceapis::device::v1::SaveRoomResponse_Error* SaveRoomResponse::release_error() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRoomResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::deviceapis::device::v1::SaveRoomResponse_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 ::deviceapis::device::v1::SaveRoomResponse_Error& SaveRoomResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::deviceapis::device::v1::SaveRoomResponse_Error&>(::deviceapis::device::v1::_SaveRoomResponse_Error_default_instance_);
}
inline const ::deviceapis::device::v1::SaveRoomResponse_Error& SaveRoomResponse::error() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRoomResponse.error)
  return _internal_error();
}
inline ::deviceapis::device::v1::SaveRoomResponse_Error* SaveRoomResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.SaveRoomResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::deviceapis::device::v1::SaveRoomResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SaveRoomResponse::unsafe_arena_set_allocated_error(::deviceapis::device::v1::SaveRoomResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.SaveRoomResponse.error)
}
inline ::deviceapis::device::v1::SaveRoomResponse_Error* SaveRoomResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::deviceapis::device::v1::SaveRoomResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::deviceapis::device::v1::SaveRoomResponse_Error* SaveRoomResponse::mutable_error() {
  ::deviceapis::device::v1::SaveRoomResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRoomResponse.error)
  return _msg;
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace device
}  // namespace deviceapis


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5froom_5fv1_2eproto_2epb_2eh
