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

#ifndef GOOGLE_PROTOBUF_INCLUDED_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5frfid_5fv1_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5frfid_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 "google/protobuf/wrappers.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_5frfid_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_5frfid_5fv1_2eproto {
  static const ::uint32_t offsets[];
};
namespace deviceapis {
namespace device {
namespace v1 {
class DeleteRfidListRequest;
struct DeleteRfidListRequestDefaultTypeInternal;
extern DeleteRfidListRequestDefaultTypeInternal _DeleteRfidListRequest_default_instance_;
class DeleteRfidListResponse;
struct DeleteRfidListResponseDefaultTypeInternal;
extern DeleteRfidListResponseDefaultTypeInternal _DeleteRfidListResponse_default_instance_;
class DeleteRfidRequest;
struct DeleteRfidRequestDefaultTypeInternal;
extern DeleteRfidRequestDefaultTypeInternal _DeleteRfidRequest_default_instance_;
class DeleteRfidResponse;
struct DeleteRfidResponseDefaultTypeInternal;
extern DeleteRfidResponseDefaultTypeInternal _DeleteRfidResponse_default_instance_;
class DeleteRfidResponse_Error;
struct DeleteRfidResponse_ErrorDefaultTypeInternal;
extern DeleteRfidResponse_ErrorDefaultTypeInternal _DeleteRfidResponse_Error_default_instance_;
class GetRfidCountRequest;
struct GetRfidCountRequestDefaultTypeInternal;
extern GetRfidCountRequestDefaultTypeInternal _GetRfidCountRequest_default_instance_;
class GetRfidCountResponse;
struct GetRfidCountResponseDefaultTypeInternal;
extern GetRfidCountResponseDefaultTypeInternal _GetRfidCountResponse_default_instance_;
class GetRfidListRequest;
struct GetRfidListRequestDefaultTypeInternal;
extern GetRfidListRequestDefaultTypeInternal _GetRfidListRequest_default_instance_;
class GetRfidListResponse;
struct GetRfidListResponseDefaultTypeInternal;
extern GetRfidListResponseDefaultTypeInternal _GetRfidListResponse_default_instance_;
class GetRfidRequest;
struct GetRfidRequestDefaultTypeInternal;
extern GetRfidRequestDefaultTypeInternal _GetRfidRequest_default_instance_;
class GetRfidResponse;
struct GetRfidResponseDefaultTypeInternal;
extern GetRfidResponseDefaultTypeInternal _GetRfidResponse_default_instance_;
class Rfid;
struct RfidDefaultTypeInternal;
extern RfidDefaultTypeInternal _Rfid_default_instance_;
class RfidPaging;
struct RfidPagingDefaultTypeInternal;
extern RfidPagingDefaultTypeInternal _RfidPaging_default_instance_;
class Rfid_SavingError;
struct Rfid_SavingErrorDefaultTypeInternal;
extern Rfid_SavingErrorDefaultTypeInternal _Rfid_SavingError_default_instance_;
class Rfid_SavingError_RelayNotFound;
struct Rfid_SavingError_RelayNotFoundDefaultTypeInternal;
extern Rfid_SavingError_RelayNotFoundDefaultTypeInternal _Rfid_SavingError_RelayNotFound_default_instance_;
class SaveRfidListRequest;
struct SaveRfidListRequestDefaultTypeInternal;
extern SaveRfidListRequestDefaultTypeInternal _SaveRfidListRequest_default_instance_;
class SaveRfidListResponse;
struct SaveRfidListResponseDefaultTypeInternal;
extern SaveRfidListResponseDefaultTypeInternal _SaveRfidListResponse_default_instance_;
class SaveRfidListResponse_Error;
struct SaveRfidListResponse_ErrorDefaultTypeInternal;
extern SaveRfidListResponse_ErrorDefaultTypeInternal _SaveRfidListResponse_Error_default_instance_;
class SaveRfidRequest;
struct SaveRfidRequestDefaultTypeInternal;
extern SaveRfidRequestDefaultTypeInternal _SaveRfidRequest_default_instance_;
class SaveRfidResponse;
struct SaveRfidResponseDefaultTypeInternal;
extern SaveRfidResponseDefaultTypeInternal _SaveRfidResponse_default_instance_;
class SaveRfidResponse_Error;
struct SaveRfidResponse_ErrorDefaultTypeInternal;
extern SaveRfidResponse_ErrorDefaultTypeInternal _SaveRfidResponse_Error_default_instance_;
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
PROTOBUF_NAMESPACE_OPEN
template <>
::deviceapis::device::v1::DeleteRfidListRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRfidListRequest>(Arena*);
template <>
::deviceapis::device::v1::DeleteRfidListResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRfidListResponse>(Arena*);
template <>
::deviceapis::device::v1::DeleteRfidRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRfidRequest>(Arena*);
template <>
::deviceapis::device::v1::DeleteRfidResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRfidResponse>(Arena*);
template <>
::deviceapis::device::v1::DeleteRfidResponse_Error* Arena::CreateMaybeMessage<::deviceapis::device::v1::DeleteRfidResponse_Error>(Arena*);
template <>
::deviceapis::device::v1::GetRfidCountRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRfidCountRequest>(Arena*);
template <>
::deviceapis::device::v1::GetRfidCountResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRfidCountResponse>(Arena*);
template <>
::deviceapis::device::v1::GetRfidListRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRfidListRequest>(Arena*);
template <>
::deviceapis::device::v1::GetRfidListResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRfidListResponse>(Arena*);
template <>
::deviceapis::device::v1::GetRfidRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRfidRequest>(Arena*);
template <>
::deviceapis::device::v1::GetRfidResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetRfidResponse>(Arena*);
template <>
::deviceapis::device::v1::Rfid* Arena::CreateMaybeMessage<::deviceapis::device::v1::Rfid>(Arena*);
template <>
::deviceapis::device::v1::RfidPaging* Arena::CreateMaybeMessage<::deviceapis::device::v1::RfidPaging>(Arena*);
template <>
::deviceapis::device::v1::Rfid_SavingError* Arena::CreateMaybeMessage<::deviceapis::device::v1::Rfid_SavingError>(Arena*);
template <>
::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* Arena::CreateMaybeMessage<::deviceapis::device::v1::Rfid_SavingError_RelayNotFound>(Arena*);
template <>
::deviceapis::device::v1::SaveRfidListRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRfidListRequest>(Arena*);
template <>
::deviceapis::device::v1::SaveRfidListResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRfidListResponse>(Arena*);
template <>
::deviceapis::device::v1::SaveRfidListResponse_Error* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRfidListResponse_Error>(Arena*);
template <>
::deviceapis::device::v1::SaveRfidRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRfidRequest>(Arena*);
template <>
::deviceapis::device::v1::SaveRfidResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRfidResponse>(Arena*);
template <>
::deviceapis::device::v1::SaveRfidResponse_Error* Arena::CreateMaybeMessage<::deviceapis::device::v1::SaveRfidResponse_Error>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace deviceapis {
namespace device {
namespace v1 {

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


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

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

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

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.DeleteRfidListResponse";
  }
  protected:
  explicit DeleteRfidListResponse(::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.DeleteRfidListResponse)
 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kIdFieldNumber = 1,
  };
  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  void clear_id() ;
  const std::string& id() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_id(Arg_&& arg, Args_... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* ptr);

  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(
      const std::string& value);
  std::string* _internal_mutable_id();

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

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.DeleteRfidResponse.Error";
  }
  protected:
  explicit DeleteRfidResponse_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.DeleteRfidResponse.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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

  typedef DeleteRfidResponse_Error Error;

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

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

  public:
  void clear_error() ;
  const ::deviceapis::device::v1::DeleteRfidResponse_Error& error() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::DeleteRfidResponse_Error* release_error();
  ::deviceapis::device::v1::DeleteRfidResponse_Error* mutable_error();
  void set_allocated_error(::deviceapis::device::v1::DeleteRfidResponse_Error* error);
  private:
  const ::deviceapis::device::v1::DeleteRfidResponse_Error& _internal_error() const;
  ::deviceapis::device::v1::DeleteRfidResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::deviceapis::device::v1::DeleteRfidResponse_Error* error);
  ::deviceapis::device::v1::DeleteRfidResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.DeleteRfidResponse)
 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::DeleteRfidResponse_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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

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

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.GetRfidCountResponse";
  }
  protected:
  explicit GetRfidCountResponse(::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.GetRfidCountResponse)
 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

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

  public:
  void clear_paging() ;
  const ::deviceapis::device::v1::RfidPaging& paging() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::RfidPaging* release_paging();
  ::deviceapis::device::v1::RfidPaging* mutable_paging();
  void set_allocated_paging(::deviceapis::device::v1::RfidPaging* paging);
  private:
  const ::deviceapis::device::v1::RfidPaging& _internal_paging() const;
  ::deviceapis::device::v1::RfidPaging* _internal_mutable_paging();
  public:
  void unsafe_arena_set_allocated_paging(
      ::deviceapis::device::v1::RfidPaging* paging);
  ::deviceapis::device::v1::RfidPaging* unsafe_arena_release_paging();
  void clear_pagination();
  PaginationCase pagination_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRfidListRequest)
 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::RfidPaging* 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

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

  public:
  void clear_data() ;
  ::deviceapis::device::v1::Rfid* mutable_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Rfid >*
      mutable_data();
  private:
  const ::deviceapis::device::v1::Rfid& _internal_data(int index) const;
  ::deviceapis::device::v1::Rfid* _internal_add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Rfid>& _internal_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Rfid>* _internal_mutable_data();
  public:
  const ::deviceapis::device::v1::Rfid& data(int index) const;
  ::deviceapis::device::v1::Rfid* add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Rfid >&
      data() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRfidListResponse)
 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::Rfid > data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kIdFieldNumber = 1,
  };
  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  void clear_id() ;
  const std::string& id() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_id(Arg_&& arg, Args_... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* ptr);

  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(
      const std::string& value);
  std::string* _internal_mutable_id();

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

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

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

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

  public:
  void clear_data() ;
  const ::deviceapis::device::v1::Rfid& data() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::Rfid* release_data();
  ::deviceapis::device::v1::Rfid* mutable_data();
  void set_allocated_data(::deviceapis::device::v1::Rfid* data);
  private:
  const ::deviceapis::device::v1::Rfid& _internal_data() const;
  ::deviceapis::device::v1::Rfid* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::deviceapis::device::v1::Rfid* data);
  ::deviceapis::device::v1::Rfid* unsafe_arena_release_data();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetRfidResponse)
 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::Rfid* 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.Rfid.SavingError.RelayNotFound)
 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

  typedef Rfid_SavingError_RelayNotFound RelayNotFound;

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

  enum : int {
    kRelayNotFoundFieldNumber = 1,
  };
  // .deviceapis.device.v1.Rfid.SavingError.RelayNotFound relay_not_found = 1;
  bool has_relay_not_found() const;
  private:
  bool _internal_has_relay_not_found() const;

  public:
  void clear_relay_not_found() ;
  const ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound& relay_not_found() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* release_relay_not_found();
  ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* mutable_relay_not_found();
  void set_allocated_relay_not_found(::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* relay_not_found);
  private:
  const ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound& _internal_relay_not_found() const;
  ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* _internal_mutable_relay_not_found();
  public:
  void unsafe_arena_set_allocated_relay_not_found(
      ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* relay_not_found);
  ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* unsafe_arena_release_relay_not_found();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.Rfid.SavingError)
 private:
  class _Internal;
  void set_has_relay_not_found();

  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::Rfid_SavingError_RelayNotFound* relay_not_found_;
    } 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

  typedef Rfid_SavingError SavingError;

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

  enum : int {
    kRelayIndexesFieldNumber = 4,
    kIdFieldNumber = 1,
    kDescriptionFieldNumber = 2,
    kSecretFieldNumber = 3,
  };
  // repeated int32 relay_indexes = 4;
  int relay_indexes_size() const;
  private:
  int _internal_relay_indexes_size() const;

  public:
  void clear_relay_indexes() ;
  ::int32_t relay_indexes(int index) const;
  void set_relay_indexes(int index, ::int32_t value);
  void add_relay_indexes(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& relay_indexes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* mutable_relay_indexes();

  private:
  ::int32_t _internal_relay_indexes(int index) const;
  void _internal_add_relay_indexes(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& _internal_relay_indexes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* _internal_mutable_relay_indexes();

  public:
  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  void clear_id() ;
  const std::string& id() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_id(Arg_&& arg, Args_... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* ptr);

  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(
      const std::string& value);
  std::string* _internal_mutable_id();

  public:
  // .google.protobuf.StringValue description = 2;
  bool has_description() const;
  void clear_description() ;
  const ::PROTOBUF_NAMESPACE_ID::StringValue& description() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::StringValue* release_description();
  ::PROTOBUF_NAMESPACE_ID::StringValue* mutable_description();
  void set_allocated_description(::PROTOBUF_NAMESPACE_ID::StringValue* description);
  private:
  const ::PROTOBUF_NAMESPACE_ID::StringValue& _internal_description() const;
  ::PROTOBUF_NAMESPACE_ID::StringValue* _internal_mutable_description();
  public:
  void unsafe_arena_set_allocated_description(
      ::PROTOBUF_NAMESPACE_ID::StringValue* description);
  ::PROTOBUF_NAMESPACE_ID::StringValue* unsafe_arena_release_description();
  // .google.protobuf.StringValue secret = 3;
  bool has_secret() const;
  void clear_secret() ;
  const ::PROTOBUF_NAMESPACE_ID::StringValue& secret() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::StringValue* release_secret();
  ::PROTOBUF_NAMESPACE_ID::StringValue* mutable_secret();
  void set_allocated_secret(::PROTOBUF_NAMESPACE_ID::StringValue* secret);
  private:
  const ::PROTOBUF_NAMESPACE_ID::StringValue& _internal_secret() const;
  ::PROTOBUF_NAMESPACE_ID::StringValue* _internal_mutable_secret();
  public:
  void unsafe_arena_set_allocated_secret(
      ::PROTOBUF_NAMESPACE_ID::StringValue* secret);
  ::PROTOBUF_NAMESPACE_ID::StringValue* unsafe_arena_release_secret();
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.Rfid)
 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_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t> relay_indexes_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _relay_indexes_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
    ::PROTOBUF_NAMESPACE_ID::StringValue* description_;
    ::PROTOBUF_NAMESPACE_ID::StringValue* secret_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.RfidPaging";
  }
  protected:
  explicit RfidPaging(::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.RfidPaging)
 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

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

  public:
  void clear_data() ;
  ::deviceapis::device::v1::Rfid* mutable_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Rfid >*
      mutable_data();
  private:
  const ::deviceapis::device::v1::Rfid& _internal_data(int index) const;
  ::deviceapis::device::v1::Rfid* _internal_add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Rfid>& _internal_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::Rfid>* _internal_mutable_data();
  public:
  const ::deviceapis::device::v1::Rfid& data(int index) const;
  ::deviceapis::device::v1::Rfid* add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::Rfid >&
      data() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRfidListRequest)
 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::Rfid > data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kIdFieldNumber = 1,
    kValidationFieldNumber = 2,
    kSavingFieldNumber = 3,
  };
  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  void clear_id() ;
  const std::string& id() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_id(Arg_&& arg, Args_... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* ptr);

  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(
      const std::string& value);
  std::string* _internal_mutable_id();

  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();
  // .deviceapis.device.v1.Rfid.SavingError saving = 3;
  bool has_saving() const;
  private:
  bool _internal_has_saving() const;

  public:
  void clear_saving() ;
  const ::deviceapis::device::v1::Rfid_SavingError& saving() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::Rfid_SavingError* release_saving();
  ::deviceapis::device::v1::Rfid_SavingError* mutable_saving();
  void set_allocated_saving(::deviceapis::device::v1::Rfid_SavingError* saving);
  private:
  const ::deviceapis::device::v1::Rfid_SavingError& _internal_saving() const;
  ::deviceapis::device::v1::Rfid_SavingError* _internal_mutable_saving();
  public:
  void unsafe_arena_set_allocated_saving(
      ::deviceapis::device::v1::Rfid_SavingError* saving);
  ::deviceapis::device::v1::Rfid_SavingError* unsafe_arena_release_saving();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRfidListResponse.Error)
 private:
  class _Internal;
  void set_has_validation();
  void set_has_saving();

  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 id_;
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::deviceapis::device::v1::ValidationError* validation_;
      ::deviceapis::device::v1::Rfid_SavingError* saving_;
    } 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

  typedef SaveRfidListResponse_Error Error;

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

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

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

  public:
  void clear_errors() ;
  ::deviceapis::device::v1::SaveRfidListResponse_Error* mutable_errors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::SaveRfidListResponse_Error >*
      mutable_errors();
  private:
  const ::deviceapis::device::v1::SaveRfidListResponse_Error& _internal_errors(int index) const;
  ::deviceapis::device::v1::SaveRfidListResponse_Error* _internal_add_errors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::SaveRfidListResponse_Error>& _internal_errors() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::SaveRfidListResponse_Error>* _internal_mutable_errors();
  public:
  const ::deviceapis::device::v1::SaveRfidListResponse_Error& errors(int index) const;
  ::deviceapis::device::v1::SaveRfidListResponse_Error* add_errors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::SaveRfidListResponse_Error >&
      errors() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRfidListResponse)
 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::Rfid > data_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::SaveRfidListResponse_Error > errors_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

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

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

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kValidationFieldNumber = 1,
    kSavingFieldNumber = 2,
  };
  // .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();
  // .deviceapis.device.v1.Rfid.SavingError saving = 2;
  bool has_saving() const;
  private:
  bool _internal_has_saving() const;

  public:
  void clear_saving() ;
  const ::deviceapis::device::v1::Rfid_SavingError& saving() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::Rfid_SavingError* release_saving();
  ::deviceapis::device::v1::Rfid_SavingError* mutable_saving();
  void set_allocated_saving(::deviceapis::device::v1::Rfid_SavingError* saving);
  private:
  const ::deviceapis::device::v1::Rfid_SavingError& _internal_saving() const;
  ::deviceapis::device::v1::Rfid_SavingError* _internal_mutable_saving();
  public:
  void unsafe_arena_set_allocated_saving(
      ::deviceapis::device::v1::Rfid_SavingError* saving);
  ::deviceapis::device::v1::Rfid_SavingError* unsafe_arena_release_saving();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRfidResponse.Error)
 private:
  class _Internal;
  void set_has_validation();
  void set_has_saving();

  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_;
      ::deviceapis::device::v1::Rfid_SavingError* saving_;
    } 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_5frfid_5fv1_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  std::string GetTypeName() const final;

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

  typedef SaveRfidResponse_Error Error;

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

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

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

  public:
  void clear_error() ;
  const ::deviceapis::device::v1::SaveRfidResponse_Error& error() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::SaveRfidResponse_Error* release_error();
  ::deviceapis::device::v1::SaveRfidResponse_Error* mutable_error();
  void set_allocated_error(::deviceapis::device::v1::SaveRfidResponse_Error* error);
  private:
  const ::deviceapis::device::v1::SaveRfidResponse_Error& _internal_error() const;
  ::deviceapis::device::v1::SaveRfidResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::deviceapis::device::v1::SaveRfidResponse_Error* error);
  ::deviceapis::device::v1::SaveRfidResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.SaveRfidResponse)
 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::Rfid* data_;
      ::deviceapis::device::v1::SaveRfidResponse_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_5frfid_5fv1_2eproto;
};

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




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


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

// DeleteRfidListRequest

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

// DeleteRfidListResponse

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

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

// DeleteRfidRequest

// string id = 1 [(.google.api.field_behavior) = REQUIRED];
inline void DeleteRfidRequest::clear_id() {
  _impl_.id_.ClearToEmpty();
}
inline const std::string& DeleteRfidRequest::id() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRfidRequest.id)
  return _internal_id();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DeleteRfidRequest::set_id(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.id_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.DeleteRfidRequest.id)
}
inline std::string* DeleteRfidRequest::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.DeleteRfidRequest.id)
  return _s;
}
inline const std::string& DeleteRfidRequest::_internal_id() const {
  return _impl_.id_.Get();
}
inline void DeleteRfidRequest::_internal_set_id(const std::string& value) {
  ;


  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* DeleteRfidRequest::_internal_mutable_id() {
  ;
  return _impl_.id_.Mutable( GetArenaForAllocation());
}
inline std::string* DeleteRfidRequest::release_id() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.DeleteRfidRequest.id)
  return _impl_.id_.Release();
}
inline void DeleteRfidRequest::set_allocated_id(std::string* value) {
  _impl_.id_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.id_.IsDefault()) {
          _impl_.id_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.DeleteRfidRequest.id)
}

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

// DeleteRfidResponse_Error

// .deviceapis.device.v1.ValidationError validation = 1;
inline bool DeleteRfidResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool DeleteRfidResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void DeleteRfidResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::deviceapis::device::v1::ValidationError* DeleteRfidResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.DeleteRfidResponse.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& DeleteRfidResponse_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& DeleteRfidResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.DeleteRfidResponse.Error.validation)
  return _internal_validation();
}
inline ::deviceapis::device::v1::ValidationError* DeleteRfidResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.DeleteRfidResponse.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 DeleteRfidResponse_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.DeleteRfidResponse.Error.validation)
}
inline ::deviceapis::device::v1::ValidationError* DeleteRfidResponse_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* DeleteRfidResponse_Error::mutable_validation() {
  ::deviceapis::device::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.DeleteRfidResponse.Error.validation)
  return _msg;
}

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

// DeleteRfidResponse

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

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

// GetRfidCountRequest

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

// GetRfidCountResponse

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

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

// GetRfidListRequest

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

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

// GetRfidListResponse

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

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

// GetRfidRequest

// string id = 1 [(.google.api.field_behavior) = REQUIRED];
inline void GetRfidRequest::clear_id() {
  _impl_.id_.ClearToEmpty();
}
inline const std::string& GetRfidRequest::id() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.GetRfidRequest.id)
  return _internal_id();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GetRfidRequest::set_id(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.id_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.GetRfidRequest.id)
}
inline std::string* GetRfidRequest::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.GetRfidRequest.id)
  return _s;
}
inline const std::string& GetRfidRequest::_internal_id() const {
  return _impl_.id_.Get();
}
inline void GetRfidRequest::_internal_set_id(const std::string& value) {
  ;


  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* GetRfidRequest::_internal_mutable_id() {
  ;
  return _impl_.id_.Mutable( GetArenaForAllocation());
}
inline std::string* GetRfidRequest::release_id() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.GetRfidRequest.id)
  return _impl_.id_.Release();
}
inline void GetRfidRequest::set_allocated_id(std::string* value) {
  _impl_.id_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.id_.IsDefault()) {
          _impl_.id_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.GetRfidRequest.id)
}

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

// GetRfidResponse

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

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

// Rfid_SavingError_RelayNotFound

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

// Rfid_SavingError

// .deviceapis.device.v1.Rfid.SavingError.RelayNotFound relay_not_found = 1;
inline bool Rfid_SavingError::has_relay_not_found() const {
  return reason_case() == kRelayNotFound;
}
inline bool Rfid_SavingError::_internal_has_relay_not_found() const {
  return reason_case() == kRelayNotFound;
}
inline void Rfid_SavingError::set_has_relay_not_found() {
  _impl_._oneof_case_[0] = kRelayNotFound;
}
inline void Rfid_SavingError::clear_relay_not_found() {
  if (reason_case() == kRelayNotFound) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.relay_not_found_;
    }
    clear_has_reason();
  }
}
inline ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* Rfid_SavingError::release_relay_not_found() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.Rfid.SavingError.relay_not_found)
  if (reason_case() == kRelayNotFound) {
    clear_has_reason();
    ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* temp = _impl_.reason_.relay_not_found_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.relay_not_found_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound& Rfid_SavingError::_internal_relay_not_found() const {
  return reason_case() == kRelayNotFound
      ? *_impl_.reason_.relay_not_found_
      : reinterpret_cast<::deviceapis::device::v1::Rfid_SavingError_RelayNotFound&>(::deviceapis::device::v1::_Rfid_SavingError_RelayNotFound_default_instance_);
}
inline const ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound& Rfid_SavingError::relay_not_found() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Rfid.SavingError.relay_not_found)
  return _internal_relay_not_found();
}
inline ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* Rfid_SavingError::unsafe_arena_release_relay_not_found() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.Rfid.SavingError.relay_not_found)
  if (reason_case() == kRelayNotFound) {
    clear_has_reason();
    ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* temp = _impl_.reason_.relay_not_found_;
    _impl_.reason_.relay_not_found_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Rfid_SavingError::unsafe_arena_set_allocated_relay_not_found(::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* relay_not_found) {
  clear_reason();
  if (relay_not_found) {
    set_has_relay_not_found();
    _impl_.reason_.relay_not_found_ = relay_not_found;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.Rfid.SavingError.relay_not_found)
}
inline ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* Rfid_SavingError::_internal_mutable_relay_not_found() {
  if (reason_case() != kRelayNotFound) {
    clear_reason();
    set_has_relay_not_found();
    _impl_.reason_.relay_not_found_ = CreateMaybeMessage< ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound >(GetArenaForAllocation());
  }
  return _impl_.reason_.relay_not_found_;
}
inline ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* Rfid_SavingError::mutable_relay_not_found() {
  ::deviceapis::device::v1::Rfid_SavingError_RelayNotFound* _msg = _internal_mutable_relay_not_found();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.Rfid.SavingError.relay_not_found)
  return _msg;
}

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

// Rfid

// string id = 1 [(.google.api.field_behavior) = REQUIRED];
inline void Rfid::clear_id() {
  _impl_.id_.ClearToEmpty();
}
inline const std::string& Rfid::id() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Rfid.id)
  return _internal_id();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Rfid::set_id(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.id_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.Rfid.id)
}
inline std::string* Rfid::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.Rfid.id)
  return _s;
}
inline const std::string& Rfid::_internal_id() const {
  return _impl_.id_.Get();
}
inline void Rfid::_internal_set_id(const std::string& value) {
  ;


  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* Rfid::_internal_mutable_id() {
  ;
  return _impl_.id_.Mutable( GetArenaForAllocation());
}
inline std::string* Rfid::release_id() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.Rfid.id)
  return _impl_.id_.Release();
}
inline void Rfid::set_allocated_id(std::string* value) {
  _impl_.id_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.id_.IsDefault()) {
          _impl_.id_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.Rfid.id)
}

// .google.protobuf.StringValue description = 2;
inline bool Rfid::has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.description_ != nullptr);
  return value;
}
inline const ::PROTOBUF_NAMESPACE_ID::StringValue& Rfid::_internal_description() const {
  const ::PROTOBUF_NAMESPACE_ID::StringValue* p = _impl_.description_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::StringValue&>(
      ::PROTOBUF_NAMESPACE_ID::_StringValue_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::StringValue& Rfid::description() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Rfid.description)
  return _internal_description();
}
inline void Rfid::unsafe_arena_set_allocated_description(
    ::PROTOBUF_NAMESPACE_ID::StringValue* description) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.description_);
  }
  _impl_.description_ = description;
  if (description) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.Rfid.description)
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Rfid::release_description() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::PROTOBUF_NAMESPACE_ID::StringValue* temp = _impl_.description_;
  _impl_.description_ = 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 ::PROTOBUF_NAMESPACE_ID::StringValue* Rfid::unsafe_arena_release_description() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.Rfid.description)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::PROTOBUF_NAMESPACE_ID::StringValue* temp = _impl_.description_;
  _impl_.description_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Rfid::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.description_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::StringValue>(GetArenaForAllocation());
    _impl_.description_ = p;
  }
  return _impl_.description_;
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Rfid::mutable_description() {
  ::PROTOBUF_NAMESPACE_ID::StringValue* _msg = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.Rfid.description)
  return _msg;
}
inline void Rfid::set_allocated_description(::PROTOBUF_NAMESPACE_ID::StringValue* description) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.description_);
  }
  if (description) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description));
    if (message_arena != submessage_arena) {
      description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, description, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.description_ = description;
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.Rfid.description)
}

// .google.protobuf.StringValue secret = 3;
inline bool Rfid::has_secret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.secret_ != nullptr);
  return value;
}
inline const ::PROTOBUF_NAMESPACE_ID::StringValue& Rfid::_internal_secret() const {
  const ::PROTOBUF_NAMESPACE_ID::StringValue* p = _impl_.secret_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::StringValue&>(
      ::PROTOBUF_NAMESPACE_ID::_StringValue_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::StringValue& Rfid::secret() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Rfid.secret)
  return _internal_secret();
}
inline void Rfid::unsafe_arena_set_allocated_secret(
    ::PROTOBUF_NAMESPACE_ID::StringValue* secret) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.secret_);
  }
  _impl_.secret_ = secret;
  if (secret) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.Rfid.secret)
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Rfid::release_secret() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::PROTOBUF_NAMESPACE_ID::StringValue* temp = _impl_.secret_;
  _impl_.secret_ = 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 ::PROTOBUF_NAMESPACE_ID::StringValue* Rfid::unsafe_arena_release_secret() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.Rfid.secret)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::PROTOBUF_NAMESPACE_ID::StringValue* temp = _impl_.secret_;
  _impl_.secret_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Rfid::_internal_mutable_secret() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.secret_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::StringValue>(GetArenaForAllocation());
    _impl_.secret_ = p;
  }
  return _impl_.secret_;
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Rfid::mutable_secret() {
  ::PROTOBUF_NAMESPACE_ID::StringValue* _msg = _internal_mutable_secret();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.Rfid.secret)
  return _msg;
}
inline void Rfid::set_allocated_secret(::PROTOBUF_NAMESPACE_ID::StringValue* secret) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.secret_);
  }
  if (secret) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(secret));
    if (message_arena != submessage_arena) {
      secret = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, secret, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.secret_ = secret;
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.Rfid.secret)
}

// repeated int32 relay_indexes = 4;
inline int Rfid::_internal_relay_indexes_size() const {
  return _impl_.relay_indexes_.size();
}
inline int Rfid::relay_indexes_size() const {
  return _internal_relay_indexes_size();
}
inline void Rfid::clear_relay_indexes() {
  _internal_mutable_relay_indexes()->Clear();
}
inline ::int32_t Rfid::relay_indexes(int index) const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.Rfid.relay_indexes)
  return _internal_relay_indexes(index);
}
inline void Rfid::set_relay_indexes(int index, ::int32_t value) {
  _internal_mutable_relay_indexes()->Set(index, value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.Rfid.relay_indexes)
}
inline void Rfid::add_relay_indexes(::int32_t value) {
  _internal_add_relay_indexes(value);
  // @@protoc_insertion_point(field_add:deviceapis.device.v1.Rfid.relay_indexes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& Rfid::relay_indexes() const {
  // @@protoc_insertion_point(field_list:deviceapis.device.v1.Rfid.relay_indexes)
  return _internal_relay_indexes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* Rfid::mutable_relay_indexes() {
  // @@protoc_insertion_point(field_mutable_list:deviceapis.device.v1.Rfid.relay_indexes)
  return _internal_mutable_relay_indexes();
}

inline ::int32_t Rfid::_internal_relay_indexes(int index) const {
  return _internal_relay_indexes().Get(index);
}
inline void Rfid::_internal_add_relay_indexes(::int32_t value) {
  _internal_mutable_relay_indexes()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& Rfid::_internal_relay_indexes() const {
  return _impl_.relay_indexes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* Rfid::_internal_mutable_relay_indexes() {
  return &_impl_.relay_indexes_;
}

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

// RfidPaging

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

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

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

// SaveRfidListRequest

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

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

// SaveRfidListResponse_Error

// string id = 1 [(.google.api.field_behavior) = REQUIRED];
inline void SaveRfidListResponse_Error::clear_id() {
  _impl_.id_.ClearToEmpty();
}
inline const std::string& SaveRfidListResponse_Error::id() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRfidListResponse.Error.id)
  return _internal_id();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void SaveRfidListResponse_Error::set_id(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.id_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.SaveRfidListResponse.Error.id)
}
inline std::string* SaveRfidListResponse_Error::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRfidListResponse.Error.id)
  return _s;
}
inline const std::string& SaveRfidListResponse_Error::_internal_id() const {
  return _impl_.id_.Get();
}
inline void SaveRfidListResponse_Error::_internal_set_id(const std::string& value) {
  ;


  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* SaveRfidListResponse_Error::_internal_mutable_id() {
  ;
  return _impl_.id_.Mutable( GetArenaForAllocation());
}
inline std::string* SaveRfidListResponse_Error::release_id() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRfidListResponse.Error.id)
  return _impl_.id_.Release();
}
inline void SaveRfidListResponse_Error::set_allocated_id(std::string* value) {
  _impl_.id_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.id_.IsDefault()) {
          _impl_.id_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.SaveRfidListResponse.Error.id)
}

// .deviceapis.device.v1.ValidationError validation = 2;
inline bool SaveRfidListResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool SaveRfidListResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void SaveRfidListResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::deviceapis::device::v1::ValidationError* SaveRfidListResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRfidListResponse.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& SaveRfidListResponse_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& SaveRfidListResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRfidListResponse.Error.validation)
  return _internal_validation();
}
inline ::deviceapis::device::v1::ValidationError* SaveRfidListResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.SaveRfidListResponse.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 SaveRfidListResponse_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.SaveRfidListResponse.Error.validation)
}
inline ::deviceapis::device::v1::ValidationError* SaveRfidListResponse_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* SaveRfidListResponse_Error::mutable_validation() {
  ::deviceapis::device::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRfidListResponse.Error.validation)
  return _msg;
}

// .deviceapis.device.v1.Rfid.SavingError saving = 3;
inline bool SaveRfidListResponse_Error::has_saving() const {
  return reason_case() == kSaving;
}
inline bool SaveRfidListResponse_Error::_internal_has_saving() const {
  return reason_case() == kSaving;
}
inline void SaveRfidListResponse_Error::set_has_saving() {
  _impl_._oneof_case_[0] = kSaving;
}
inline void SaveRfidListResponse_Error::clear_saving() {
  if (reason_case() == kSaving) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.saving_;
    }
    clear_has_reason();
  }
}
inline ::deviceapis::device::v1::Rfid_SavingError* SaveRfidListResponse_Error::release_saving() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRfidListResponse.Error.saving)
  if (reason_case() == kSaving) {
    clear_has_reason();
    ::deviceapis::device::v1::Rfid_SavingError* temp = _impl_.reason_.saving_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.saving_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::deviceapis::device::v1::Rfid_SavingError& SaveRfidListResponse_Error::_internal_saving() const {
  return reason_case() == kSaving
      ? *_impl_.reason_.saving_
      : reinterpret_cast<::deviceapis::device::v1::Rfid_SavingError&>(::deviceapis::device::v1::_Rfid_SavingError_default_instance_);
}
inline const ::deviceapis::device::v1::Rfid_SavingError& SaveRfidListResponse_Error::saving() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRfidListResponse.Error.saving)
  return _internal_saving();
}
inline ::deviceapis::device::v1::Rfid_SavingError* SaveRfidListResponse_Error::unsafe_arena_release_saving() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.SaveRfidListResponse.Error.saving)
  if (reason_case() == kSaving) {
    clear_has_reason();
    ::deviceapis::device::v1::Rfid_SavingError* temp = _impl_.reason_.saving_;
    _impl_.reason_.saving_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SaveRfidListResponse_Error::unsafe_arena_set_allocated_saving(::deviceapis::device::v1::Rfid_SavingError* saving) {
  clear_reason();
  if (saving) {
    set_has_saving();
    _impl_.reason_.saving_ = saving;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.SaveRfidListResponse.Error.saving)
}
inline ::deviceapis::device::v1::Rfid_SavingError* SaveRfidListResponse_Error::_internal_mutable_saving() {
  if (reason_case() != kSaving) {
    clear_reason();
    set_has_saving();
    _impl_.reason_.saving_ = CreateMaybeMessage< ::deviceapis::device::v1::Rfid_SavingError >(GetArenaForAllocation());
  }
  return _impl_.reason_.saving_;
}
inline ::deviceapis::device::v1::Rfid_SavingError* SaveRfidListResponse_Error::mutable_saving() {
  ::deviceapis::device::v1::Rfid_SavingError* _msg = _internal_mutable_saving();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRfidListResponse.Error.saving)
  return _msg;
}

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

// SaveRfidListResponse

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

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

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

// SaveRfidRequest

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

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

// SaveRfidResponse_Error

// .deviceapis.device.v1.ValidationError validation = 1;
inline bool SaveRfidResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool SaveRfidResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void SaveRfidResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::deviceapis::device::v1::ValidationError* SaveRfidResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRfidResponse.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& SaveRfidResponse_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& SaveRfidResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRfidResponse.Error.validation)
  return _internal_validation();
}
inline ::deviceapis::device::v1::ValidationError* SaveRfidResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.SaveRfidResponse.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 SaveRfidResponse_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.SaveRfidResponse.Error.validation)
}
inline ::deviceapis::device::v1::ValidationError* SaveRfidResponse_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* SaveRfidResponse_Error::mutable_validation() {
  ::deviceapis::device::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRfidResponse.Error.validation)
  return _msg;
}

// .deviceapis.device.v1.Rfid.SavingError saving = 2;
inline bool SaveRfidResponse_Error::has_saving() const {
  return reason_case() == kSaving;
}
inline bool SaveRfidResponse_Error::_internal_has_saving() const {
  return reason_case() == kSaving;
}
inline void SaveRfidResponse_Error::set_has_saving() {
  _impl_._oneof_case_[0] = kSaving;
}
inline void SaveRfidResponse_Error::clear_saving() {
  if (reason_case() == kSaving) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.saving_;
    }
    clear_has_reason();
  }
}
inline ::deviceapis::device::v1::Rfid_SavingError* SaveRfidResponse_Error::release_saving() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.SaveRfidResponse.Error.saving)
  if (reason_case() == kSaving) {
    clear_has_reason();
    ::deviceapis::device::v1::Rfid_SavingError* temp = _impl_.reason_.saving_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.saving_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::deviceapis::device::v1::Rfid_SavingError& SaveRfidResponse_Error::_internal_saving() const {
  return reason_case() == kSaving
      ? *_impl_.reason_.saving_
      : reinterpret_cast<::deviceapis::device::v1::Rfid_SavingError&>(::deviceapis::device::v1::_Rfid_SavingError_default_instance_);
}
inline const ::deviceapis::device::v1::Rfid_SavingError& SaveRfidResponse_Error::saving() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.SaveRfidResponse.Error.saving)
  return _internal_saving();
}
inline ::deviceapis::device::v1::Rfid_SavingError* SaveRfidResponse_Error::unsafe_arena_release_saving() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.SaveRfidResponse.Error.saving)
  if (reason_case() == kSaving) {
    clear_has_reason();
    ::deviceapis::device::v1::Rfid_SavingError* temp = _impl_.reason_.saving_;
    _impl_.reason_.saving_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SaveRfidResponse_Error::unsafe_arena_set_allocated_saving(::deviceapis::device::v1::Rfid_SavingError* saving) {
  clear_reason();
  if (saving) {
    set_has_saving();
    _impl_.reason_.saving_ = saving;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.SaveRfidResponse.Error.saving)
}
inline ::deviceapis::device::v1::Rfid_SavingError* SaveRfidResponse_Error::_internal_mutable_saving() {
  if (reason_case() != kSaving) {
    clear_reason();
    set_has_saving();
    _impl_.reason_.saving_ = CreateMaybeMessage< ::deviceapis::device::v1::Rfid_SavingError >(GetArenaForAllocation());
  }
  return _impl_.reason_.saving_;
}
inline ::deviceapis::device::v1::Rfid_SavingError* SaveRfidResponse_Error::mutable_saving() {
  ::deviceapis::device::v1::Rfid_SavingError* _msg = _internal_mutable_saving();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.SaveRfidResponse.Error.saving)
  return _msg;
}

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

// SaveRfidResponse

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

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

inline bool SaveRfidResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void SaveRfidResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline SaveRfidResponse::TypeCase SaveRfidResponse::type_case() const {
  return SaveRfidResponse::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_5frfid_5fv1_2eproto_2epb_2eh
