// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: mod-user.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_mod_2duser_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mod_2duser_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3020000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3020001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mod_2duser_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mod_2duser_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mod_2duser_2eproto;
class ReqUserAdd;
struct ReqUserAddDefaultTypeInternal;
extern ReqUserAddDefaultTypeInternal _ReqUserAdd_default_instance_;
class ReqUserDel;
struct ReqUserDelDefaultTypeInternal;
extern ReqUserDelDefaultTypeInternal _ReqUserDel_default_instance_;
class ReqUserLogin;
struct ReqUserLoginDefaultTypeInternal;
extern ReqUserLoginDefaultTypeInternal _ReqUserLogin_default_instance_;
class ReqUserUpdate;
struct ReqUserUpdateDefaultTypeInternal;
extern ReqUserUpdateDefaultTypeInternal _ReqUserUpdate_default_instance_;
class RetUserElement;
struct RetUserElementDefaultTypeInternal;
extern RetUserElementDefaultTypeInternal _RetUserElement_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::ReqUserAdd* Arena::CreateMaybeMessage<::ReqUserAdd>(Arena*);
template<> ::ReqUserDel* Arena::CreateMaybeMessage<::ReqUserDel>(Arena*);
template<> ::ReqUserLogin* Arena::CreateMaybeMessage<::ReqUserLogin>(Arena*);
template<> ::ReqUserUpdate* Arena::CreateMaybeMessage<::ReqUserUpdate>(Arena*);
template<> ::RetUserElement* Arena::CreateMaybeMessage<::RetUserElement>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum RetUserElement_Role : int {
  RetUserElement_Role_None = 0,
  RetUserElement_Role_Admin = 1,
  RetUserElement_Role_Normal = 2,
  RetUserElement_Role_RetUserElement_Role_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  RetUserElement_Role_RetUserElement_Role_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool RetUserElement_Role_IsValid(int value);
constexpr RetUserElement_Role RetUserElement_Role_Role_MIN = RetUserElement_Role_None;
constexpr RetUserElement_Role RetUserElement_Role_Role_MAX = RetUserElement_Role_Normal;
constexpr int RetUserElement_Role_Role_ARRAYSIZE = RetUserElement_Role_Role_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RetUserElement_Role_descriptor();
template<typename T>
inline const std::string& RetUserElement_Role_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RetUserElement_Role>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RetUserElement_Role_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RetUserElement_Role_descriptor(), enum_t_value);
}
inline bool RetUserElement_Role_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RetUserElement_Role* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RetUserElement_Role>(
    RetUserElement_Role_descriptor(), name, value);
}
enum ReqUserAdd_Role : int {
  ReqUserAdd_Role_None = 0,
  ReqUserAdd_Role_Admin = 1,
  ReqUserAdd_Role_Normal = 2,
  ReqUserAdd_Role_ReqUserAdd_Role_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ReqUserAdd_Role_ReqUserAdd_Role_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ReqUserAdd_Role_IsValid(int value);
constexpr ReqUserAdd_Role ReqUserAdd_Role_Role_MIN = ReqUserAdd_Role_None;
constexpr ReqUserAdd_Role ReqUserAdd_Role_Role_MAX = ReqUserAdd_Role_Normal;
constexpr int ReqUserAdd_Role_Role_ARRAYSIZE = ReqUserAdd_Role_Role_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReqUserAdd_Role_descriptor();
template<typename T>
inline const std::string& ReqUserAdd_Role_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ReqUserAdd_Role>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ReqUserAdd_Role_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ReqUserAdd_Role_descriptor(), enum_t_value);
}
inline bool ReqUserAdd_Role_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReqUserAdd_Role* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReqUserAdd_Role>(
    ReqUserAdd_Role_descriptor(), name, value);
}
// ===================================================================

class RetUserElement final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:RetUserElement) */ {
 public:
  inline RetUserElement() : RetUserElement(nullptr) {}
  ~RetUserElement() override;
  explicit PROTOBUF_CONSTEXPR RetUserElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RetUserElement& default_instance() {
    return *internal_default_instance();
  }
  static inline const RetUserElement* internal_default_instance() {
    return reinterpret_cast<const RetUserElement*>(
               &_RetUserElement_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

  RetUserElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RetUserElement>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RetUserElement& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RetUserElement& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RetUserElement* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetUserElement";
  }
  protected:
  explicit RetUserElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef RetUserElement_Role Role;
  static constexpr Role None =
    RetUserElement_Role_None;
  static constexpr Role Admin =
    RetUserElement_Role_Admin;
  static constexpr Role Normal =
    RetUserElement_Role_Normal;
  static inline bool Role_IsValid(int value) {
    return RetUserElement_Role_IsValid(value);
  }
  static constexpr Role Role_MIN =
    RetUserElement_Role_Role_MIN;
  static constexpr Role Role_MAX =
    RetUserElement_Role_Role_MAX;
  static constexpr int Role_ARRAYSIZE =
    RetUserElement_Role_Role_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Role_descriptor() {
    return RetUserElement_Role_descriptor();
  }
  template<typename T>
  static inline const std::string& Role_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Role>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Role_Name.");
    return RetUserElement_Role_Name(enum_t_value);
  }
  static inline bool Role_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Role* value) {
    return RetUserElement_Role_Parse(name, value);
  }

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

  enum : int {
    kUsernameFieldNumber = 2,
    kIdFieldNumber = 1,
    kRoleFieldNumber = 3,
    kImmutableFieldNumber = 4,
  };
  // string username = 2;
  void clear_username();
  const std::string& username() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_username(ArgT0&& arg0, ArgT... args);
  std::string* mutable_username();
  PROTOBUF_NODISCARD std::string* release_username();
  void set_allocated_username(std::string* username);
  private:
  const std::string& _internal_username() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_username(const std::string& value);
  std::string* _internal_mutable_username();
  public:

  // int32 id = 1;
  void clear_id();
  int32_t id() const;
  void set_id(int32_t value);
  private:
  int32_t _internal_id() const;
  void _internal_set_id(int32_t value);
  public:

  // .RetUserElement.Role role = 3;
  void clear_role();
  ::RetUserElement_Role role() const;
  void set_role(::RetUserElement_Role value);
  private:
  ::RetUserElement_Role _internal_role() const;
  void _internal_set_role(::RetUserElement_Role value);
  public:

  // bool immutable = 4;
  void clear_immutable();
  bool immutable() const;
  void set_immutable(bool value);
  private:
  bool _internal_immutable() const;
  void _internal_set_immutable(bool value);
  public:

  // @@protoc_insertion_point(class_scope:RetUserElement)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr username_;
  int32_t id_;
  int role_;
  bool immutable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2duser_2eproto;
};
// -------------------------------------------------------------------

class ReqUserAdd final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ReqUserAdd) */ {
 public:
  inline ReqUserAdd() : ReqUserAdd(nullptr) {}
  ~ReqUserAdd() override;
  explicit PROTOBUF_CONSTEXPR ReqUserAdd(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReqUserAdd& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReqUserAdd* internal_default_instance() {
    return reinterpret_cast<const ReqUserAdd*>(
               &_ReqUserAdd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

  ReqUserAdd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqUserAdd>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqUserAdd& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqUserAdd& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqUserAdd* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqUserAdd";
  }
  protected:
  explicit ReqUserAdd(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef ReqUserAdd_Role Role;
  static constexpr Role None =
    ReqUserAdd_Role_None;
  static constexpr Role Admin =
    ReqUserAdd_Role_Admin;
  static constexpr Role Normal =
    ReqUserAdd_Role_Normal;
  static inline bool Role_IsValid(int value) {
    return ReqUserAdd_Role_IsValid(value);
  }
  static constexpr Role Role_MIN =
    ReqUserAdd_Role_Role_MIN;
  static constexpr Role Role_MAX =
    ReqUserAdd_Role_Role_MAX;
  static constexpr int Role_ARRAYSIZE =
    ReqUserAdd_Role_Role_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Role_descriptor() {
    return ReqUserAdd_Role_descriptor();
  }
  template<typename T>
  static inline const std::string& Role_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Role>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Role_Name.");
    return ReqUserAdd_Role_Name(enum_t_value);
  }
  static inline bool Role_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Role* value) {
    return ReqUserAdd_Role_Parse(name, value);
  }

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

  enum : int {
    kUsernameFieldNumber = 1,
    kPwdFieldNumber = 2,
    kRoleFieldNumber = 3,
  };
  // string username = 1;
  void clear_username();
  const std::string& username() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_username(ArgT0&& arg0, ArgT... args);
  std::string* mutable_username();
  PROTOBUF_NODISCARD std::string* release_username();
  void set_allocated_username(std::string* username);
  private:
  const std::string& _internal_username() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_username(const std::string& value);
  std::string* _internal_mutable_username();
  public:

  // string pwd = 2;
  void clear_pwd();
  const std::string& pwd() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pwd(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pwd();
  PROTOBUF_NODISCARD std::string* release_pwd();
  void set_allocated_pwd(std::string* pwd);
  private:
  const std::string& _internal_pwd() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pwd(const std::string& value);
  std::string* _internal_mutable_pwd();
  public:

  // .ReqUserAdd.Role role = 3;
  void clear_role();
  ::ReqUserAdd_Role role() const;
  void set_role(::ReqUserAdd_Role value);
  private:
  ::ReqUserAdd_Role _internal_role() const;
  void _internal_set_role(::ReqUserAdd_Role value);
  public:

  // @@protoc_insertion_point(class_scope:ReqUserAdd)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr username_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pwd_;
  int role_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2duser_2eproto;
};
// -------------------------------------------------------------------

class ReqUserUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ReqUserUpdate) */ {
 public:
  inline ReqUserUpdate() : ReqUserUpdate(nullptr) {}
  ~ReqUserUpdate() override;
  explicit PROTOBUF_CONSTEXPR ReqUserUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReqUserUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReqUserUpdate* internal_default_instance() {
    return reinterpret_cast<const ReqUserUpdate*>(
               &_ReqUserUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

  ReqUserUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqUserUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqUserUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqUserUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqUserUpdate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqUserUpdate";
  }
  protected:
  explicit ReqUserUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kOldPwdFieldNumber = 2,
    kNewPwdFieldNumber = 3,
    kIdFieldNumber = 1,
  };
  // string oldPwd = 2;
  void clear_oldpwd();
  const std::string& oldpwd() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_oldpwd(ArgT0&& arg0, ArgT... args);
  std::string* mutable_oldpwd();
  PROTOBUF_NODISCARD std::string* release_oldpwd();
  void set_allocated_oldpwd(std::string* oldpwd);
  private:
  const std::string& _internal_oldpwd() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldpwd(const std::string& value);
  std::string* _internal_mutable_oldpwd();
  public:

  // string NewPwd = 3;
  void clear_newpwd();
  const std::string& newpwd() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_newpwd(ArgT0&& arg0, ArgT... args);
  std::string* mutable_newpwd();
  PROTOBUF_NODISCARD std::string* release_newpwd();
  void set_allocated_newpwd(std::string* newpwd);
  private:
  const std::string& _internal_newpwd() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_newpwd(const std::string& value);
  std::string* _internal_mutable_newpwd();
  public:

  // int32 id = 1;
  void clear_id();
  int32_t id() const;
  void set_id(int32_t value);
  private:
  int32_t _internal_id() const;
  void _internal_set_id(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:ReqUserUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldpwd_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newpwd_;
  int32_t id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2duser_2eproto;
};
// -------------------------------------------------------------------

class ReqUserDel final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ReqUserDel) */ {
 public:
  inline ReqUserDel() : ReqUserDel(nullptr) {}
  ~ReqUserDel() override;
  explicit PROTOBUF_CONSTEXPR ReqUserDel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReqUserDel& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReqUserDel* internal_default_instance() {
    return reinterpret_cast<const ReqUserDel*>(
               &_ReqUserDel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

  ReqUserDel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqUserDel>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqUserDel& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqUserDel& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqUserDel* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqUserDel";
  }
  protected:
  explicit ReqUserDel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIdFieldNumber = 1,
    kUidFieldNumber = 2,
  };
  // repeated int32 id = 1;
  int id_size() const;
  private:
  int _internal_id_size() const;
  public:
  void clear_id();
  private:
  int32_t _internal_id(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_id() const;
  void _internal_add_id(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_id();
  public:
  int32_t id(int index) const;
  void set_id(int index, int32_t value);
  void add_id(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      id() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_id();

  // int32 uid = 2;
  void clear_uid();
  int32_t uid() const;
  void set_uid(int32_t value);
  private:
  int32_t _internal_uid() const;
  void _internal_set_uid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:ReqUserDel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > id_;
  mutable std::atomic<int> _id_cached_byte_size_;
  int32_t uid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2duser_2eproto;
};
// -------------------------------------------------------------------

class ReqUserLogin final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ReqUserLogin) */ {
 public:
  inline ReqUserLogin() : ReqUserLogin(nullptr) {}
  ~ReqUserLogin() override;
  explicit PROTOBUF_CONSTEXPR ReqUserLogin(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReqUserLogin& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReqUserLogin* internal_default_instance() {
    return reinterpret_cast<const ReqUserLogin*>(
               &_ReqUserLogin_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

  ReqUserLogin* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqUserLogin>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqUserLogin& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqUserLogin& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqUserLogin* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqUserLogin";
  }
  protected:
  explicit ReqUserLogin(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kUsernameFieldNumber = 1,
    kPwdFieldNumber = 2,
  };
  // string username = 1;
  void clear_username();
  const std::string& username() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_username(ArgT0&& arg0, ArgT... args);
  std::string* mutable_username();
  PROTOBUF_NODISCARD std::string* release_username();
  void set_allocated_username(std::string* username);
  private:
  const std::string& _internal_username() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_username(const std::string& value);
  std::string* _internal_mutable_username();
  public:

  // string pwd = 2;
  void clear_pwd();
  const std::string& pwd() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pwd(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pwd();
  PROTOBUF_NODISCARD std::string* release_pwd();
  void set_allocated_pwd(std::string* pwd);
  private:
  const std::string& _internal_pwd() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pwd(const std::string& value);
  std::string* _internal_mutable_pwd();
  public:

  // @@protoc_insertion_point(class_scope:ReqUserLogin)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr username_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pwd_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2duser_2eproto;
};
// ===================================================================


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

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

// int32 id = 1;
inline void RetUserElement::clear_id() {
  id_ = 0;
}
inline int32_t RetUserElement::_internal_id() const {
  return id_;
}
inline int32_t RetUserElement::id() const {
  // @@protoc_insertion_point(field_get:RetUserElement.id)
  return _internal_id();
}
inline void RetUserElement::_internal_set_id(int32_t value) {
  
  id_ = value;
}
inline void RetUserElement::set_id(int32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:RetUserElement.id)
}

// string username = 2;
inline void RetUserElement::clear_username() {
  username_.ClearToEmpty();
}
inline const std::string& RetUserElement::username() const {
  // @@protoc_insertion_point(field_get:RetUserElement.username)
  return _internal_username();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetUserElement::set_username(ArgT0&& arg0, ArgT... args) {
 
 username_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetUserElement.username)
}
inline std::string* RetUserElement::mutable_username() {
  std::string* _s = _internal_mutable_username();
  // @@protoc_insertion_point(field_mutable:RetUserElement.username)
  return _s;
}
inline const std::string& RetUserElement::_internal_username() const {
  return username_.Get();
}
inline void RetUserElement::_internal_set_username(const std::string& value) {
  
  username_.Set(value, GetArenaForAllocation());
}
inline std::string* RetUserElement::_internal_mutable_username() {
  
  return username_.Mutable(GetArenaForAllocation());
}
inline std::string* RetUserElement::release_username() {
  // @@protoc_insertion_point(field_release:RetUserElement.username)
  return username_.Release();
}
inline void RetUserElement::set_allocated_username(std::string* username) {
  if (username != nullptr) {
    
  } else {
    
  }
  username_.SetAllocated(username, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (username_.IsDefault()) {
    username_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetUserElement.username)
}

// .RetUserElement.Role role = 3;
inline void RetUserElement::clear_role() {
  role_ = 0;
}
inline ::RetUserElement_Role RetUserElement::_internal_role() const {
  return static_cast< ::RetUserElement_Role >(role_);
}
inline ::RetUserElement_Role RetUserElement::role() const {
  // @@protoc_insertion_point(field_get:RetUserElement.role)
  return _internal_role();
}
inline void RetUserElement::_internal_set_role(::RetUserElement_Role value) {
  
  role_ = value;
}
inline void RetUserElement::set_role(::RetUserElement_Role value) {
  _internal_set_role(value);
  // @@protoc_insertion_point(field_set:RetUserElement.role)
}

// bool immutable = 4;
inline void RetUserElement::clear_immutable() {
  immutable_ = false;
}
inline bool RetUserElement::_internal_immutable() const {
  return immutable_;
}
inline bool RetUserElement::immutable() const {
  // @@protoc_insertion_point(field_get:RetUserElement.immutable)
  return _internal_immutable();
}
inline void RetUserElement::_internal_set_immutable(bool value) {
  
  immutable_ = value;
}
inline void RetUserElement::set_immutable(bool value) {
  _internal_set_immutable(value);
  // @@protoc_insertion_point(field_set:RetUserElement.immutable)
}

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

// ReqUserAdd

// string username = 1;
inline void ReqUserAdd::clear_username() {
  username_.ClearToEmpty();
}
inline const std::string& ReqUserAdd::username() const {
  // @@protoc_insertion_point(field_get:ReqUserAdd.username)
  return _internal_username();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqUserAdd::set_username(ArgT0&& arg0, ArgT... args) {
 
 username_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqUserAdd.username)
}
inline std::string* ReqUserAdd::mutable_username() {
  std::string* _s = _internal_mutable_username();
  // @@protoc_insertion_point(field_mutable:ReqUserAdd.username)
  return _s;
}
inline const std::string& ReqUserAdd::_internal_username() const {
  return username_.Get();
}
inline void ReqUserAdd::_internal_set_username(const std::string& value) {
  
  username_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqUserAdd::_internal_mutable_username() {
  
  return username_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqUserAdd::release_username() {
  // @@protoc_insertion_point(field_release:ReqUserAdd.username)
  return username_.Release();
}
inline void ReqUserAdd::set_allocated_username(std::string* username) {
  if (username != nullptr) {
    
  } else {
    
  }
  username_.SetAllocated(username, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (username_.IsDefault()) {
    username_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqUserAdd.username)
}

// string pwd = 2;
inline void ReqUserAdd::clear_pwd() {
  pwd_.ClearToEmpty();
}
inline const std::string& ReqUserAdd::pwd() const {
  // @@protoc_insertion_point(field_get:ReqUserAdd.pwd)
  return _internal_pwd();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqUserAdd::set_pwd(ArgT0&& arg0, ArgT... args) {
 
 pwd_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqUserAdd.pwd)
}
inline std::string* ReqUserAdd::mutable_pwd() {
  std::string* _s = _internal_mutable_pwd();
  // @@protoc_insertion_point(field_mutable:ReqUserAdd.pwd)
  return _s;
}
inline const std::string& ReqUserAdd::_internal_pwd() const {
  return pwd_.Get();
}
inline void ReqUserAdd::_internal_set_pwd(const std::string& value) {
  
  pwd_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqUserAdd::_internal_mutable_pwd() {
  
  return pwd_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqUserAdd::release_pwd() {
  // @@protoc_insertion_point(field_release:ReqUserAdd.pwd)
  return pwd_.Release();
}
inline void ReqUserAdd::set_allocated_pwd(std::string* pwd) {
  if (pwd != nullptr) {
    
  } else {
    
  }
  pwd_.SetAllocated(pwd, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (pwd_.IsDefault()) {
    pwd_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqUserAdd.pwd)
}

// .ReqUserAdd.Role role = 3;
inline void ReqUserAdd::clear_role() {
  role_ = 0;
}
inline ::ReqUserAdd_Role ReqUserAdd::_internal_role() const {
  return static_cast< ::ReqUserAdd_Role >(role_);
}
inline ::ReqUserAdd_Role ReqUserAdd::role() const {
  // @@protoc_insertion_point(field_get:ReqUserAdd.role)
  return _internal_role();
}
inline void ReqUserAdd::_internal_set_role(::ReqUserAdd_Role value) {
  
  role_ = value;
}
inline void ReqUserAdd::set_role(::ReqUserAdd_Role value) {
  _internal_set_role(value);
  // @@protoc_insertion_point(field_set:ReqUserAdd.role)
}

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

// ReqUserUpdate

// int32 id = 1;
inline void ReqUserUpdate::clear_id() {
  id_ = 0;
}
inline int32_t ReqUserUpdate::_internal_id() const {
  return id_;
}
inline int32_t ReqUserUpdate::id() const {
  // @@protoc_insertion_point(field_get:ReqUserUpdate.id)
  return _internal_id();
}
inline void ReqUserUpdate::_internal_set_id(int32_t value) {
  
  id_ = value;
}
inline void ReqUserUpdate::set_id(int32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:ReqUserUpdate.id)
}

// string oldPwd = 2;
inline void ReqUserUpdate::clear_oldpwd() {
  oldpwd_.ClearToEmpty();
}
inline const std::string& ReqUserUpdate::oldpwd() const {
  // @@protoc_insertion_point(field_get:ReqUserUpdate.oldPwd)
  return _internal_oldpwd();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqUserUpdate::set_oldpwd(ArgT0&& arg0, ArgT... args) {
 
 oldpwd_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqUserUpdate.oldPwd)
}
inline std::string* ReqUserUpdate::mutable_oldpwd() {
  std::string* _s = _internal_mutable_oldpwd();
  // @@protoc_insertion_point(field_mutable:ReqUserUpdate.oldPwd)
  return _s;
}
inline const std::string& ReqUserUpdate::_internal_oldpwd() const {
  return oldpwd_.Get();
}
inline void ReqUserUpdate::_internal_set_oldpwd(const std::string& value) {
  
  oldpwd_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqUserUpdate::_internal_mutable_oldpwd() {
  
  return oldpwd_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqUserUpdate::release_oldpwd() {
  // @@protoc_insertion_point(field_release:ReqUserUpdate.oldPwd)
  return oldpwd_.Release();
}
inline void ReqUserUpdate::set_allocated_oldpwd(std::string* oldpwd) {
  if (oldpwd != nullptr) {
    
  } else {
    
  }
  oldpwd_.SetAllocated(oldpwd, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (oldpwd_.IsDefault()) {
    oldpwd_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqUserUpdate.oldPwd)
}

// string NewPwd = 3;
inline void ReqUserUpdate::clear_newpwd() {
  newpwd_.ClearToEmpty();
}
inline const std::string& ReqUserUpdate::newpwd() const {
  // @@protoc_insertion_point(field_get:ReqUserUpdate.NewPwd)
  return _internal_newpwd();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqUserUpdate::set_newpwd(ArgT0&& arg0, ArgT... args) {
 
 newpwd_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqUserUpdate.NewPwd)
}
inline std::string* ReqUserUpdate::mutable_newpwd() {
  std::string* _s = _internal_mutable_newpwd();
  // @@protoc_insertion_point(field_mutable:ReqUserUpdate.NewPwd)
  return _s;
}
inline const std::string& ReqUserUpdate::_internal_newpwd() const {
  return newpwd_.Get();
}
inline void ReqUserUpdate::_internal_set_newpwd(const std::string& value) {
  
  newpwd_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqUserUpdate::_internal_mutable_newpwd() {
  
  return newpwd_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqUserUpdate::release_newpwd() {
  // @@protoc_insertion_point(field_release:ReqUserUpdate.NewPwd)
  return newpwd_.Release();
}
inline void ReqUserUpdate::set_allocated_newpwd(std::string* newpwd) {
  if (newpwd != nullptr) {
    
  } else {
    
  }
  newpwd_.SetAllocated(newpwd, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (newpwd_.IsDefault()) {
    newpwd_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqUserUpdate.NewPwd)
}

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

// ReqUserDel

// repeated int32 id = 1;
inline int ReqUserDel::_internal_id_size() const {
  return id_.size();
}
inline int ReqUserDel::id_size() const {
  return _internal_id_size();
}
inline void ReqUserDel::clear_id() {
  id_.Clear();
}
inline int32_t ReqUserDel::_internal_id(int index) const {
  return id_.Get(index);
}
inline int32_t ReqUserDel::id(int index) const {
  // @@protoc_insertion_point(field_get:ReqUserDel.id)
  return _internal_id(index);
}
inline void ReqUserDel::set_id(int index, int32_t value) {
  id_.Set(index, value);
  // @@protoc_insertion_point(field_set:ReqUserDel.id)
}
inline void ReqUserDel::_internal_add_id(int32_t value) {
  id_.Add(value);
}
inline void ReqUserDel::add_id(int32_t value) {
  _internal_add_id(value);
  // @@protoc_insertion_point(field_add:ReqUserDel.id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReqUserDel::_internal_id() const {
  return id_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReqUserDel::id() const {
  // @@protoc_insertion_point(field_list:ReqUserDel.id)
  return _internal_id();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReqUserDel::_internal_mutable_id() {
  return &id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReqUserDel::mutable_id() {
  // @@protoc_insertion_point(field_mutable_list:ReqUserDel.id)
  return _internal_mutable_id();
}

// int32 uid = 2;
inline void ReqUserDel::clear_uid() {
  uid_ = 0;
}
inline int32_t ReqUserDel::_internal_uid() const {
  return uid_;
}
inline int32_t ReqUserDel::uid() const {
  // @@protoc_insertion_point(field_get:ReqUserDel.uid)
  return _internal_uid();
}
inline void ReqUserDel::_internal_set_uid(int32_t value) {
  
  uid_ = value;
}
inline void ReqUserDel::set_uid(int32_t value) {
  _internal_set_uid(value);
  // @@protoc_insertion_point(field_set:ReqUserDel.uid)
}

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

// ReqUserLogin

// string username = 1;
inline void ReqUserLogin::clear_username() {
  username_.ClearToEmpty();
}
inline const std::string& ReqUserLogin::username() const {
  // @@protoc_insertion_point(field_get:ReqUserLogin.username)
  return _internal_username();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqUserLogin::set_username(ArgT0&& arg0, ArgT... args) {
 
 username_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqUserLogin.username)
}
inline std::string* ReqUserLogin::mutable_username() {
  std::string* _s = _internal_mutable_username();
  // @@protoc_insertion_point(field_mutable:ReqUserLogin.username)
  return _s;
}
inline const std::string& ReqUserLogin::_internal_username() const {
  return username_.Get();
}
inline void ReqUserLogin::_internal_set_username(const std::string& value) {
  
  username_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqUserLogin::_internal_mutable_username() {
  
  return username_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqUserLogin::release_username() {
  // @@protoc_insertion_point(field_release:ReqUserLogin.username)
  return username_.Release();
}
inline void ReqUserLogin::set_allocated_username(std::string* username) {
  if (username != nullptr) {
    
  } else {
    
  }
  username_.SetAllocated(username, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (username_.IsDefault()) {
    username_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqUserLogin.username)
}

// string pwd = 2;
inline void ReqUserLogin::clear_pwd() {
  pwd_.ClearToEmpty();
}
inline const std::string& ReqUserLogin::pwd() const {
  // @@protoc_insertion_point(field_get:ReqUserLogin.pwd)
  return _internal_pwd();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqUserLogin::set_pwd(ArgT0&& arg0, ArgT... args) {
 
 pwd_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqUserLogin.pwd)
}
inline std::string* ReqUserLogin::mutable_pwd() {
  std::string* _s = _internal_mutable_pwd();
  // @@protoc_insertion_point(field_mutable:ReqUserLogin.pwd)
  return _s;
}
inline const std::string& ReqUserLogin::_internal_pwd() const {
  return pwd_.Get();
}
inline void ReqUserLogin::_internal_set_pwd(const std::string& value) {
  
  pwd_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqUserLogin::_internal_mutable_pwd() {
  
  return pwd_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqUserLogin::release_pwd() {
  // @@protoc_insertion_point(field_release:ReqUserLogin.pwd)
  return pwd_.Release();
}
inline void ReqUserLogin::set_allocated_pwd(std::string* pwd) {
  if (pwd != nullptr) {
    
  } else {
    
  }
  pwd_.SetAllocated(pwd, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (pwd_.IsDefault()) {
    pwd_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqUserLogin.pwd)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::RetUserElement_Role> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::RetUserElement_Role>() {
  return ::RetUserElement_Role_descriptor();
}
template <> struct is_proto_enum< ::ReqUserAdd_Role> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ReqUserAdd_Role>() {
  return ::ReqUserAdd_Role_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_mod_2duser_2eproto
