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

#include "deviceapis/device/v1/deviceapis_device_user_v1.pb.h"

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteUserRequestDefaultTypeInternal _DeleteUserRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteUserResponse::DeleteUserResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteUserResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteUserResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteUserResponseDefaultTypeInternal() {}
  union {
    DeleteUserResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteUserResponseDefaultTypeInternal _DeleteUserResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetUserListRequest::GetUserListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetUserListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetUserListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetUserListRequestDefaultTypeInternal() {}
  union {
    GetUserListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetUserListRequestDefaultTypeInternal _GetUserListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetUserListResponse::GetUserListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.data_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GetUserListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetUserListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetUserListResponseDefaultTypeInternal() {}
  union {
    GetUserListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetUserListResponseDefaultTypeInternal _GetUserListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserNameReplaceRequest_ReplaceTo::PostUserNameReplaceRequest_ReplaceTo(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.target_username_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserNameReplaceRequest_ReplaceToDefaultTypeInternal _PostUserNameReplaceRequest_ReplaceTo_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserNameReplaceRequest::PostUserNameReplaceRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.username_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostUserNameReplaceRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostUserNameReplaceRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostUserNameReplaceRequestDefaultTypeInternal() {}
  union {
    PostUserNameReplaceRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserNameReplaceRequestDefaultTypeInternal _PostUserNameReplaceRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserNameReplaceResponse::PostUserNameReplaceResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct PostUserNameReplaceResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostUserNameReplaceResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostUserNameReplaceResponseDefaultTypeInternal() {}
  union {
    PostUserNameReplaceResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserNameReplaceResponseDefaultTypeInternal _PostUserNameReplaceResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserPasswordReplaceRequest_ReplaceTo::PostUserPasswordReplaceRequest_ReplaceTo(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.password_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserPasswordReplaceRequest_ReplaceToDefaultTypeInternal _PostUserPasswordReplaceRequest_ReplaceTo_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserPasswordReplaceRequest::PostUserPasswordReplaceRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.username_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostUserPasswordReplaceRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostUserPasswordReplaceRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostUserPasswordReplaceRequestDefaultTypeInternal() {}
  union {
    PostUserPasswordReplaceRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserPasswordReplaceRequestDefaultTypeInternal _PostUserPasswordReplaceRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserPasswordReplaceResponse::PostUserPasswordReplaceResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct PostUserPasswordReplaceResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostUserPasswordReplaceResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostUserPasswordReplaceResponseDefaultTypeInternal() {}
  union {
    PostUserPasswordReplaceResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserPasswordReplaceResponseDefaultTypeInternal _PostUserPasswordReplaceResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserPermissionReplaceRequest_ReplaceTo::PostUserPermissionReplaceRequest_ReplaceTo(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.permission_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct PostUserPermissionReplaceRequest_ReplaceToDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostUserPermissionReplaceRequest_ReplaceToDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostUserPermissionReplaceRequest_ReplaceToDefaultTypeInternal() {}
  union {
    PostUserPermissionReplaceRequest_ReplaceTo _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserPermissionReplaceRequest_ReplaceToDefaultTypeInternal _PostUserPermissionReplaceRequest_ReplaceTo_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserPermissionReplaceRequest::PostUserPermissionReplaceRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.username_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostUserPermissionReplaceRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostUserPermissionReplaceRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostUserPermissionReplaceRequestDefaultTypeInternal() {}
  union {
    PostUserPermissionReplaceRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserPermissionReplaceRequestDefaultTypeInternal _PostUserPermissionReplaceRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostUserPermissionReplaceResponse::PostUserPermissionReplaceResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct PostUserPermissionReplaceResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostUserPermissionReplaceResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostUserPermissionReplaceResponseDefaultTypeInternal() {}
  union {
    PostUserPermissionReplaceResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostUserPermissionReplaceResponseDefaultTypeInternal _PostUserPermissionReplaceResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SaveUserRequest::SaveUserRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct SaveUserRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SaveUserRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SaveUserRequestDefaultTypeInternal() {}
  union {
    SaveUserRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveUserRequestDefaultTypeInternal _SaveUserRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SaveUserResponse::SaveUserResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct SaveUserResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SaveUserResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SaveUserResponseDefaultTypeInternal() {}
  union {
    SaveUserResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveUserResponseDefaultTypeInternal _SaveUserResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR User_Permission::User_Permission(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.permission_name_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.is_enabled_)*/ false

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 User_PermissionDefaultTypeInternal _User_Permission_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR User::User(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.permission_)*/{}
  , /*decltype(_impl_.username_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.password_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserDefaultTypeInternal _User_default_instance_;
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
namespace deviceapis {
namespace device {
namespace v1 {
// ===================================================================

class DeleteUserRequest::_Internal {
 public:
};

DeleteUserRequest::DeleteUserRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.DeleteUserRequest)
}
DeleteUserRequest::DeleteUserRequest(const DeleteUserRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteUserRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.username_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    _this->_impl_.username_.Set(from._internal_username(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.DeleteUserRequest)
}

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

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

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

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

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

void DeleteUserRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.DeleteUserRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.username_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* DeleteUserRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    const std::string& _s = this->_internal_username();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.DeleteUserRequest.username");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

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

::size_t DeleteUserRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.DeleteUserRequest)
  ::size_t total_size = 0;

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_username());
  }

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

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

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

  if (!from._internal_username().empty()) {
    _this->_internal_set_username(from._internal_username());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DeleteUserRequest::CopyFrom(const DeleteUserRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.DeleteUserRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void DeleteUserRequest::InternalSwap(DeleteUserRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.username_, lhs_arena,
                                       &other->_impl_.username_, rhs_arena);
}

std::string DeleteUserRequest::GetTypeName() const {
  return "deviceapis.device.v1.DeleteUserRequest";
}

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

class DeleteUserResponse::_Internal {
 public:
};

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

inline void DeleteUserResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

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

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

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

void DeleteUserResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.DeleteUserResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* DeleteUserResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

::size_t DeleteUserResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.DeleteUserResponse)
  ::size_t total_size = 0;

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

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

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

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

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DeleteUserResponse::CopyFrom(const DeleteUserResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.DeleteUserResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void DeleteUserResponse::InternalSwap(DeleteUserResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string DeleteUserResponse::GetTypeName() const {
  return "deviceapis.device.v1.DeleteUserResponse";
}

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

class GetUserListRequest::_Internal {
 public:
};

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

inline void GetUserListRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

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

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

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

void GetUserListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetUserListRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* GetUserListRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

::size_t GetUserListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetUserListRequest)
  ::size_t total_size = 0;

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

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

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

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

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetUserListRequest::CopyFrom(const GetUserListRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetUserListRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void GetUserListRequest::InternalSwap(GetUserListRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string GetUserListRequest::GetTypeName() const {
  return "deviceapis.device.v1.GetUserListRequest";
}

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

class GetUserListResponse::_Internal {
 public:
};

GetUserListResponse::GetUserListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.GetUserListResponse)
}
GetUserListResponse::GetUserListResponse(const GetUserListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetUserListResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.data_){from._impl_.data_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.GetUserListResponse)
}

inline void GetUserListResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.data_){arena}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

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

inline void GetUserListResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_data()->~RepeatedPtrField();
}

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

void GetUserListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetUserListResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* GetUserListResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .deviceapis.device.v1.User data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_data(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // repeated .deviceapis.device.v1.User data = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_data_size()); i < n; i++) {
    const auto& repfield = this->_internal_data(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
  }

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

::size_t GetUserListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetUserListResponse)
  ::size_t total_size = 0;

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

  // repeated .deviceapis.device.v1.User data = 1;
  total_size += 1UL * this->_internal_data_size();
  for (const auto& msg : this->_internal_data()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

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

  _this->_internal_mutable_data()->MergeFrom(from._internal_data());
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetUserListResponse::CopyFrom(const GetUserListResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetUserListResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void GetUserListResponse::InternalSwap(GetUserListResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _internal_mutable_data()->InternalSwap(other->_internal_mutable_data());
}

std::string GetUserListResponse::GetTypeName() const {
  return "deviceapis.device.v1.GetUserListResponse";
}

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

class PostUserNameReplaceRequest_ReplaceTo::_Internal {
 public:
};

PostUserNameReplaceRequest_ReplaceTo::PostUserNameReplaceRequest_ReplaceTo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo)
}
PostUserNameReplaceRequest_ReplaceTo::PostUserNameReplaceRequest_ReplaceTo(const PostUserNameReplaceRequest_ReplaceTo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostUserNameReplaceRequest_ReplaceTo* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.target_username_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.target_username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.target_username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_target_username().empty()) {
    _this->_impl_.target_username_.Set(from._internal_target_username(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo)
}

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

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

PostUserNameReplaceRequest_ReplaceTo::~PostUserNameReplaceRequest_ReplaceTo() {
  // @@protoc_insertion_point(destructor:deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

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

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

void PostUserNameReplaceRequest_ReplaceTo::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.target_username_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* PostUserNameReplaceRequest_ReplaceTo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string target_username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_target_username();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostUserNameReplaceRequest_ReplaceTo::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string target_username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_target_username().empty()) {
    const std::string& _s = this->_internal_target_username();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo.target_username");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

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

::size_t PostUserNameReplaceRequest_ReplaceTo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo)
  ::size_t total_size = 0;

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

  // string target_username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_target_username().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_target_username());
  }

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

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

void PostUserNameReplaceRequest_ReplaceTo::MergeFrom(const PostUserNameReplaceRequest_ReplaceTo& from) {
  PostUserNameReplaceRequest_ReplaceTo* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_target_username().empty()) {
    _this->_internal_set_target_username(from._internal_target_username());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserNameReplaceRequest_ReplaceTo::CopyFrom(const PostUserNameReplaceRequest_ReplaceTo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserNameReplaceRequest_ReplaceTo::InternalSwap(PostUserNameReplaceRequest_ReplaceTo* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.target_username_, lhs_arena,
                                       &other->_impl_.target_username_, rhs_arena);
}

std::string PostUserNameReplaceRequest_ReplaceTo::GetTypeName() const {
  return "deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo";
}

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

class PostUserNameReplaceRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<PostUserNameReplaceRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(PostUserNameReplaceRequest, _impl_._has_bits_);
  static const ::deviceapis::device::v1::PostUserNameReplaceRequest_ReplaceTo& data(const PostUserNameReplaceRequest* msg);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::deviceapis::device::v1::PostUserNameReplaceRequest_ReplaceTo&
PostUserNameReplaceRequest::_Internal::data(const PostUserNameReplaceRequest* msg) {
  return *msg->_impl_.data_;
}
PostUserNameReplaceRequest::PostUserNameReplaceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.PostUserNameReplaceRequest)
}
PostUserNameReplaceRequest::PostUserNameReplaceRequest(const PostUserNameReplaceRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostUserNameReplaceRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.username_) {}

    , decltype(_impl_.data_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    _this->_impl_.username_.Set(from._internal_username(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.data_ = new ::deviceapis::device::v1::PostUserNameReplaceRequest_ReplaceTo(*from._impl_.data_);
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.PostUserNameReplaceRequest)
}

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

    , decltype(_impl_.data_){nullptr}
  };
  _impl_.username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void PostUserNameReplaceRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.username_.Destroy();
  if (this != internal_default_instance()) delete _impl_.data_;
}

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

void PostUserNameReplaceRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserNameReplaceRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* PostUserNameReplaceRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    const std::string& _s = this->_internal_username();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.PostUserNameReplaceRequest.username");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

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

::size_t PostUserNameReplaceRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserNameReplaceRequest)
  ::size_t total_size = 0;

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_username());
  }

  // .deviceapis.device.v1.PostUserNameReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.data_);
  }

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

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

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

  if (!from._internal_username().empty()) {
    _this->_internal_set_username(from._internal_username());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_data()->::deviceapis::device::v1::PostUserNameReplaceRequest_ReplaceTo::MergeFrom(
        from._internal_data());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserNameReplaceRequest::CopyFrom(const PostUserNameReplaceRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserNameReplaceRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserNameReplaceRequest::InternalSwap(PostUserNameReplaceRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.username_, lhs_arena,
                                       &other->_impl_.username_, rhs_arena);
  swap(_impl_.data_, other->_impl_.data_);
}

std::string PostUserNameReplaceRequest::GetTypeName() const {
  return "deviceapis.device.v1.PostUserNameReplaceRequest";
}

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

class PostUserNameReplaceResponse::_Internal {
 public:
};

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

inline void PostUserNameReplaceResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

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

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

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

void PostUserNameReplaceResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserNameReplaceResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* PostUserNameReplaceResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

::size_t PostUserNameReplaceResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserNameReplaceResponse)
  ::size_t total_size = 0;

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

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

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

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

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserNameReplaceResponse::CopyFrom(const PostUserNameReplaceResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserNameReplaceResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserNameReplaceResponse::InternalSwap(PostUserNameReplaceResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string PostUserNameReplaceResponse::GetTypeName() const {
  return "deviceapis.device.v1.PostUserNameReplaceResponse";
}

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

class PostUserPasswordReplaceRequest_ReplaceTo::_Internal {
 public:
};

PostUserPasswordReplaceRequest_ReplaceTo::PostUserPasswordReplaceRequest_ReplaceTo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo)
}
PostUserPasswordReplaceRequest_ReplaceTo::PostUserPasswordReplaceRequest_ReplaceTo(const PostUserPasswordReplaceRequest_ReplaceTo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostUserPasswordReplaceRequest_ReplaceTo* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.password_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.password_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.password_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_password().empty()) {
    _this->_impl_.password_.Set(from._internal_password(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo)
}

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

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

PostUserPasswordReplaceRequest_ReplaceTo::~PostUserPasswordReplaceRequest_ReplaceTo() {
  // @@protoc_insertion_point(destructor:deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

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

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

void PostUserPasswordReplaceRequest_ReplaceTo::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.password_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* PostUserPasswordReplaceRequest_ReplaceTo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string password = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_password();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostUserPasswordReplaceRequest_ReplaceTo::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string password = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_password().empty()) {
    const std::string& _s = this->_internal_password();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo.password");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

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

::size_t PostUserPasswordReplaceRequest_ReplaceTo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo)
  ::size_t total_size = 0;

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

  // string password = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_password().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_password());
  }

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

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

void PostUserPasswordReplaceRequest_ReplaceTo::MergeFrom(const PostUserPasswordReplaceRequest_ReplaceTo& from) {
  PostUserPasswordReplaceRequest_ReplaceTo* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_password().empty()) {
    _this->_internal_set_password(from._internal_password());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserPasswordReplaceRequest_ReplaceTo::CopyFrom(const PostUserPasswordReplaceRequest_ReplaceTo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserPasswordReplaceRequest_ReplaceTo::InternalSwap(PostUserPasswordReplaceRequest_ReplaceTo* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.password_, lhs_arena,
                                       &other->_impl_.password_, rhs_arena);
}

std::string PostUserPasswordReplaceRequest_ReplaceTo::GetTypeName() const {
  return "deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo";
}

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

class PostUserPasswordReplaceRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<PostUserPasswordReplaceRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(PostUserPasswordReplaceRequest, _impl_._has_bits_);
  static const ::deviceapis::device::v1::PostUserPasswordReplaceRequest_ReplaceTo& data(const PostUserPasswordReplaceRequest* msg);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::deviceapis::device::v1::PostUserPasswordReplaceRequest_ReplaceTo&
PostUserPasswordReplaceRequest::_Internal::data(const PostUserPasswordReplaceRequest* msg) {
  return *msg->_impl_.data_;
}
PostUserPasswordReplaceRequest::PostUserPasswordReplaceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.PostUserPasswordReplaceRequest)
}
PostUserPasswordReplaceRequest::PostUserPasswordReplaceRequest(const PostUserPasswordReplaceRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostUserPasswordReplaceRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.username_) {}

    , decltype(_impl_.data_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    _this->_impl_.username_.Set(from._internal_username(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.data_ = new ::deviceapis::device::v1::PostUserPasswordReplaceRequest_ReplaceTo(*from._impl_.data_);
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.PostUserPasswordReplaceRequest)
}

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

    , decltype(_impl_.data_){nullptr}
  };
  _impl_.username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void PostUserPasswordReplaceRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.username_.Destroy();
  if (this != internal_default_instance()) delete _impl_.data_;
}

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

void PostUserPasswordReplaceRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserPasswordReplaceRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* PostUserPasswordReplaceRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    const std::string& _s = this->_internal_username();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.PostUserPasswordReplaceRequest.username");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

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

::size_t PostUserPasswordReplaceRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserPasswordReplaceRequest)
  ::size_t total_size = 0;

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_username());
  }

  // .deviceapis.device.v1.PostUserPasswordReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.data_);
  }

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

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

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

  if (!from._internal_username().empty()) {
    _this->_internal_set_username(from._internal_username());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_data()->::deviceapis::device::v1::PostUserPasswordReplaceRequest_ReplaceTo::MergeFrom(
        from._internal_data());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserPasswordReplaceRequest::CopyFrom(const PostUserPasswordReplaceRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserPasswordReplaceRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserPasswordReplaceRequest::InternalSwap(PostUserPasswordReplaceRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.username_, lhs_arena,
                                       &other->_impl_.username_, rhs_arena);
  swap(_impl_.data_, other->_impl_.data_);
}

std::string PostUserPasswordReplaceRequest::GetTypeName() const {
  return "deviceapis.device.v1.PostUserPasswordReplaceRequest";
}

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

class PostUserPasswordReplaceResponse::_Internal {
 public:
};

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

inline void PostUserPasswordReplaceResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

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

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

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

void PostUserPasswordReplaceResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserPasswordReplaceResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* PostUserPasswordReplaceResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

::size_t PostUserPasswordReplaceResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserPasswordReplaceResponse)
  ::size_t total_size = 0;

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

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

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

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

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserPasswordReplaceResponse::CopyFrom(const PostUserPasswordReplaceResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserPasswordReplaceResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserPasswordReplaceResponse::InternalSwap(PostUserPasswordReplaceResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string PostUserPasswordReplaceResponse::GetTypeName() const {
  return "deviceapis.device.v1.PostUserPasswordReplaceResponse";
}

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

class PostUserPermissionReplaceRequest_ReplaceTo::_Internal {
 public:
};

PostUserPermissionReplaceRequest_ReplaceTo::PostUserPermissionReplaceRequest_ReplaceTo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo)
}
PostUserPermissionReplaceRequest_ReplaceTo::PostUserPermissionReplaceRequest_ReplaceTo(const PostUserPermissionReplaceRequest_ReplaceTo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostUserPermissionReplaceRequest_ReplaceTo* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.permission_){from._impl_.permission_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo)
}

inline void PostUserPermissionReplaceRequest_ReplaceTo::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.permission_){arena}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

PostUserPermissionReplaceRequest_ReplaceTo::~PostUserPermissionReplaceRequest_ReplaceTo() {
  // @@protoc_insertion_point(destructor:deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostUserPermissionReplaceRequest_ReplaceTo::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_permission()->~RepeatedPtrField();
}

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

void PostUserPermissionReplaceRequest_ReplaceTo::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* PostUserPermissionReplaceRequest_ReplaceTo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .deviceapis.device.v1.User.Permission permission = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_permission(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostUserPermissionReplaceRequest_ReplaceTo::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .deviceapis.device.v1.User.Permission permission = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_permission_size()); i < n; i++) {
    const auto& repfield = this->_internal_permission(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
  }

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

::size_t PostUserPermissionReplaceRequest_ReplaceTo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo)
  ::size_t total_size = 0;

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

  // repeated .deviceapis.device.v1.User.Permission permission = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  total_size += 1UL * this->_internal_permission_size();
  for (const auto& msg : this->_internal_permission()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

void PostUserPermissionReplaceRequest_ReplaceTo::MergeFrom(const PostUserPermissionReplaceRequest_ReplaceTo& from) {
  PostUserPermissionReplaceRequest_ReplaceTo* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_mutable_permission()->MergeFrom(from._internal_permission());
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserPermissionReplaceRequest_ReplaceTo::CopyFrom(const PostUserPermissionReplaceRequest_ReplaceTo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserPermissionReplaceRequest_ReplaceTo::InternalSwap(PostUserPermissionReplaceRequest_ReplaceTo* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _internal_mutable_permission()->InternalSwap(other->_internal_mutable_permission());
}

std::string PostUserPermissionReplaceRequest_ReplaceTo::GetTypeName() const {
  return "deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo";
}

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

class PostUserPermissionReplaceRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<PostUserPermissionReplaceRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(PostUserPermissionReplaceRequest, _impl_._has_bits_);
  static const ::deviceapis::device::v1::PostUserPermissionReplaceRequest_ReplaceTo& data(const PostUserPermissionReplaceRequest* msg);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::deviceapis::device::v1::PostUserPermissionReplaceRequest_ReplaceTo&
PostUserPermissionReplaceRequest::_Internal::data(const PostUserPermissionReplaceRequest* msg) {
  return *msg->_impl_.data_;
}
PostUserPermissionReplaceRequest::PostUserPermissionReplaceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.PostUserPermissionReplaceRequest)
}
PostUserPermissionReplaceRequest::PostUserPermissionReplaceRequest(const PostUserPermissionReplaceRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostUserPermissionReplaceRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.username_) {}

    , decltype(_impl_.data_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    _this->_impl_.username_.Set(from._internal_username(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.data_ = new ::deviceapis::device::v1::PostUserPermissionReplaceRequest_ReplaceTo(*from._impl_.data_);
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.PostUserPermissionReplaceRequest)
}

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

    , decltype(_impl_.data_){nullptr}
  };
  _impl_.username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void PostUserPermissionReplaceRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.username_.Destroy();
  if (this != internal_default_instance()) delete _impl_.data_;
}

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

void PostUserPermissionReplaceRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserPermissionReplaceRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* PostUserPermissionReplaceRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    const std::string& _s = this->_internal_username();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.PostUserPermissionReplaceRequest.username");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

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

::size_t PostUserPermissionReplaceRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserPermissionReplaceRequest)
  ::size_t total_size = 0;

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_username());
  }

  // .deviceapis.device.v1.PostUserPermissionReplaceRequest.ReplaceTo data = 2 [(.google.api.field_behavior) = REQUIRED];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.data_);
  }

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

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

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

  if (!from._internal_username().empty()) {
    _this->_internal_set_username(from._internal_username());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_data()->::deviceapis::device::v1::PostUserPermissionReplaceRequest_ReplaceTo::MergeFrom(
        from._internal_data());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserPermissionReplaceRequest::CopyFrom(const PostUserPermissionReplaceRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserPermissionReplaceRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserPermissionReplaceRequest::InternalSwap(PostUserPermissionReplaceRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.username_, lhs_arena,
                                       &other->_impl_.username_, rhs_arena);
  swap(_impl_.data_, other->_impl_.data_);
}

std::string PostUserPermissionReplaceRequest::GetTypeName() const {
  return "deviceapis.device.v1.PostUserPermissionReplaceRequest";
}

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

class PostUserPermissionReplaceResponse::_Internal {
 public:
};

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

inline void PostUserPermissionReplaceResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

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

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

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

void PostUserPermissionReplaceResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.PostUserPermissionReplaceResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* PostUserPermissionReplaceResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

::size_t PostUserPermissionReplaceResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.PostUserPermissionReplaceResponse)
  ::size_t total_size = 0;

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

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

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

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

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostUserPermissionReplaceResponse::CopyFrom(const PostUserPermissionReplaceResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.PostUserPermissionReplaceResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PostUserPermissionReplaceResponse::InternalSwap(PostUserPermissionReplaceResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string PostUserPermissionReplaceResponse::GetTypeName() const {
  return "deviceapis.device.v1.PostUserPermissionReplaceResponse";
}

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

class SaveUserRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<SaveUserRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(SaveUserRequest, _impl_._has_bits_);
  static const ::deviceapis::device::v1::User& data(const SaveUserRequest* msg);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::deviceapis::device::v1::User&
SaveUserRequest::_Internal::data(const SaveUserRequest* msg) {
  return *msg->_impl_.data_;
}
SaveUserRequest::SaveUserRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.SaveUserRequest)
}
SaveUserRequest::SaveUserRequest(const SaveUserRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SaveUserRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.data_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.data_ = new ::deviceapis::device::v1::User(*from._impl_.data_);
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.SaveUserRequest)
}

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

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

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

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

void SaveUserRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.SaveUserRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* SaveUserRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .deviceapis.device.v1.User data = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  cached_has_bits = _impl_._has_bits_[0];
  // .deviceapis.device.v1.User data = 1 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

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

::size_t SaveUserRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.SaveUserRequest)
  ::size_t total_size = 0;

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

  // .deviceapis.device.v1.User data = 1 [(.google.api.field_behavior) = REQUIRED];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.data_);
  }

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

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

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

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_data()->::deviceapis::device::v1::User::MergeFrom(
        from._internal_data());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SaveUserRequest::CopyFrom(const SaveUserRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.SaveUserRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string SaveUserRequest::GetTypeName() const {
  return "deviceapis.device.v1.SaveUserRequest";
}

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

class SaveUserResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::deviceapis::device::v1::SaveUserResponse, _impl_._oneof_case_);
  static const ::deviceapis::device::v1::User& data(const SaveUserResponse* msg);
};

const ::deviceapis::device::v1::User&
SaveUserResponse::_Internal::data(const SaveUserResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void SaveUserResponse::set_allocated_data(::deviceapis::device::v1::User* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.SaveUserResponse.data)
}
SaveUserResponse::SaveUserResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.SaveUserResponse)
}
SaveUserResponse::SaveUserResponse(const SaveUserResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SaveUserResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::deviceapis::device::v1::User::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.SaveUserResponse)
}

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

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

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

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

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


void SaveUserResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.SaveUserResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

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

  // .deviceapis.device.v1.User data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

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

::size_t SaveUserResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.SaveUserResponse)
  ::size_t total_size = 0;

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

  switch (type_case()) {
    // .deviceapis.device.v1.User data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::deviceapis::device::v1::User::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SaveUserResponse::CopyFrom(const SaveUserResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.SaveUserResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string SaveUserResponse::GetTypeName() const {
  return "deviceapis.device.v1.SaveUserResponse";
}

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

class User_Permission::_Internal {
 public:
};

User_Permission::User_Permission(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.User.Permission)
}
User_Permission::User_Permission(const User_Permission& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  User_Permission* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.permission_name_) {}

    , decltype(_impl_.is_enabled_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.permission_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.permission_name_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_permission_name().empty()) {
    _this->_impl_.permission_name_.Set(from._internal_permission_name(), _this->GetArenaForAllocation());
  }
  _this->_impl_.is_enabled_ = from._impl_.is_enabled_;
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.User.Permission)
}

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

    , decltype(_impl_.is_enabled_) { false }

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

User_Permission::~User_Permission() {
  // @@protoc_insertion_point(destructor:deviceapis.device.v1.User.Permission)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

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

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

void User_Permission::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.User.Permission)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.permission_name_.ClearToEmpty();
  _impl_.is_enabled_ = false;
  _internal_metadata_.Clear<std::string>();
}

const char* User_Permission::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string permission_name = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_permission_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // bool is_enabled = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.is_enabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* User_Permission::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.User.Permission)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string permission_name = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_permission_name().empty()) {
    const std::string& _s = this->_internal_permission_name();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.User.Permission.permission_name");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // bool is_enabled = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_is_enabled() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        2, this->_internal_is_enabled(), target);
  }

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

::size_t User_Permission::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.User.Permission)
  ::size_t total_size = 0;

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

  // string permission_name = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_permission_name().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_permission_name());
  }

  // bool is_enabled = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_is_enabled() != 0) {
    total_size += 2;
  }

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

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

void User_Permission::MergeFrom(const User_Permission& from) {
  User_Permission* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.User.Permission)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_permission_name().empty()) {
    _this->_internal_set_permission_name(from._internal_permission_name());
  }
  if (from._internal_is_enabled() != 0) {
    _this->_internal_set_is_enabled(from._internal_is_enabled());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void User_Permission::CopyFrom(const User_Permission& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.User.Permission)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void User_Permission::InternalSwap(User_Permission* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.permission_name_, lhs_arena,
                                       &other->_impl_.permission_name_, rhs_arena);

  swap(_impl_.is_enabled_, other->_impl_.is_enabled_);
}

std::string User_Permission::GetTypeName() const {
  return "deviceapis.device.v1.User.Permission";
}

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

class User::_Internal {
 public:
};

User::User(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.User)
}
User::User(const User& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  User* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.permission_){from._impl_.permission_}
    , decltype(_impl_.username_) {}

    , decltype(_impl_.password_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.username_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.username_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    _this->_impl_.username_.Set(from._internal_username(), _this->GetArenaForAllocation());
  }
  _impl_.password_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.password_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_password().empty()) {
    _this->_impl_.password_.Set(from._internal_password(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.User)
}

inline void User::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.permission_){arena}
    , decltype(_impl_.username_) {}

    , decltype(_impl_.password_) {}

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

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

inline void User::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_permission()->~RepeatedPtrField();
  _impl_.username_.Destroy();
  _impl_.password_.Destroy();
}

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

void User::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.User)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_mutable_permission()->Clear();
  _impl_.username_.ClearToEmpty();
  _impl_.password_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* User::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string password = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_password();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .deviceapis.device.v1.User.Permission permission = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_permission(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    const std::string& _s = this->_internal_username();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.User.username");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // string password = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_password().empty()) {
    const std::string& _s = this->_internal_password();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.User.password");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  // repeated .deviceapis.device.v1.User.Permission permission = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_permission_size()); i < n; i++) {
    const auto& repfield = this->_internal_permission(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
  }

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

::size_t User::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.User)
  ::size_t total_size = 0;

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

  // repeated .deviceapis.device.v1.User.Permission permission = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  total_size += 1UL * this->_internal_permission_size();
  for (const auto& msg : this->_internal_permission()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // string username = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_username().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_username());
  }

  // string password = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_password().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_password());
  }

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

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

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

  _this->_internal_mutable_permission()->MergeFrom(from._internal_permission());
  if (!from._internal_username().empty()) {
    _this->_internal_set_username(from._internal_username());
  }
  if (!from._internal_password().empty()) {
    _this->_internal_set_password(from._internal_password());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void User::CopyFrom(const User& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.User)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void User::InternalSwap(User* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _internal_mutable_permission()->InternalSwap(other->_internal_mutable_permission());
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.username_, lhs_arena,
                                       &other->_impl_.username_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.password_, lhs_arena,
                                       &other->_impl_.password_, rhs_arena);
}

std::string User::GetTypeName() const {
  return "deviceapis.device.v1.User";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::DeleteUserRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::DeleteUserRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::DeleteUserRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::DeleteUserResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::DeleteUserResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::DeleteUserResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetUserListRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetUserListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetUserListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetUserListResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetUserListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetUserListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserNameReplaceRequest_ReplaceTo*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserNameReplaceRequest_ReplaceTo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserNameReplaceRequest_ReplaceTo >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserNameReplaceRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserNameReplaceRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserNameReplaceRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserNameReplaceResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserNameReplaceResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserNameReplaceResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserPasswordReplaceRequest_ReplaceTo*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserPasswordReplaceRequest_ReplaceTo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserPasswordReplaceRequest_ReplaceTo >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserPasswordReplaceRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserPasswordReplaceRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserPasswordReplaceRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserPasswordReplaceResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserPasswordReplaceResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserPasswordReplaceResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserPermissionReplaceRequest_ReplaceTo*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserPermissionReplaceRequest_ReplaceTo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserPermissionReplaceRequest_ReplaceTo >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserPermissionReplaceRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserPermissionReplaceRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserPermissionReplaceRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::PostUserPermissionReplaceResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::PostUserPermissionReplaceResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::PostUserPermissionReplaceResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::SaveUserRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::SaveUserRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::SaveUserRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::SaveUserResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::SaveUserResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::SaveUserResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::User_Permission*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::User_Permission >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::User_Permission >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::User*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::User >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::User >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"