// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: mysqlx.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_mysqlx_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mysqlx_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021012 < 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_bases.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>
#include <google/protobuf/descriptor.pb.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mysqlx_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mysqlx_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mysqlx_2eproto;
namespace Mysqlx {
class ClientMessages;
struct ClientMessagesDefaultTypeInternal;
extern ClientMessagesDefaultTypeInternal _ClientMessages_default_instance_;
class Error;
struct ErrorDefaultTypeInternal;
extern ErrorDefaultTypeInternal _Error_default_instance_;
class Ok;
struct OkDefaultTypeInternal;
extern OkDefaultTypeInternal _Ok_default_instance_;
class ServerMessages;
struct ServerMessagesDefaultTypeInternal;
extern ServerMessagesDefaultTypeInternal _ServerMessages_default_instance_;
}  // namespace Mysqlx
PROTOBUF_NAMESPACE_OPEN
template<> ::Mysqlx::ClientMessages* Arena::CreateMaybeMessage<::Mysqlx::ClientMessages>(Arena*);
template<> ::Mysqlx::Error* Arena::CreateMaybeMessage<::Mysqlx::Error>(Arena*);
template<> ::Mysqlx::Ok* Arena::CreateMaybeMessage<::Mysqlx::Ok>(Arena*);
template<> ::Mysqlx::ServerMessages* Arena::CreateMaybeMessage<::Mysqlx::ServerMessages>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace Mysqlx {

enum ClientMessages_Type : int {
  ClientMessages_Type_CON_CAPABILITIES_GET = 1,
  ClientMessages_Type_CON_CAPABILITIES_SET = 2,
  ClientMessages_Type_CON_CLOSE = 3,
  ClientMessages_Type_SESS_AUTHENTICATE_START = 4,
  ClientMessages_Type_SESS_AUTHENTICATE_CONTINUE = 5,
  ClientMessages_Type_SESS_RESET = 6,
  ClientMessages_Type_SESS_CLOSE = 7,
  ClientMessages_Type_SQL_STMT_EXECUTE = 12,
  ClientMessages_Type_CRUD_FIND = 17,
  ClientMessages_Type_CRUD_INSERT = 18,
  ClientMessages_Type_CRUD_UPDATE = 19,
  ClientMessages_Type_CRUD_DELETE = 20,
  ClientMessages_Type_EXPECT_OPEN = 24,
  ClientMessages_Type_EXPECT_CLOSE = 25,
  ClientMessages_Type_CRUD_CREATE_VIEW = 30,
  ClientMessages_Type_CRUD_MODIFY_VIEW = 31,
  ClientMessages_Type_CRUD_DROP_VIEW = 32,
  ClientMessages_Type_PREPARE_PREPARE = 40,
  ClientMessages_Type_PREPARE_EXECUTE = 41,
  ClientMessages_Type_PREPARE_DEALLOCATE = 42,
  ClientMessages_Type_CURSOR_OPEN = 43,
  ClientMessages_Type_CURSOR_CLOSE = 44,
  ClientMessages_Type_CURSOR_FETCH = 45,
  ClientMessages_Type_COMPRESSION = 46
};
bool ClientMessages_Type_IsValid(int value);
constexpr ClientMessages_Type ClientMessages_Type_Type_MIN = ClientMessages_Type_CON_CAPABILITIES_GET;
constexpr ClientMessages_Type ClientMessages_Type_Type_MAX = ClientMessages_Type_COMPRESSION;
constexpr int ClientMessages_Type_Type_ARRAYSIZE = ClientMessages_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientMessages_Type_descriptor();
template<typename T>
inline const std::string& ClientMessages_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientMessages_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientMessages_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientMessages_Type_descriptor(), enum_t_value);
}
inline bool ClientMessages_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientMessages_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientMessages_Type>(
    ClientMessages_Type_descriptor(), name, value);
}
enum ServerMessages_Type : int {
  ServerMessages_Type_OK = 0,
  ServerMessages_Type_ERROR = 1,
  ServerMessages_Type_CONN_CAPABILITIES = 2,
  ServerMessages_Type_SESS_AUTHENTICATE_CONTINUE = 3,
  ServerMessages_Type_SESS_AUTHENTICATE_OK = 4,
  ServerMessages_Type_NOTICE = 11,
  ServerMessages_Type_RESULTSET_COLUMN_META_DATA = 12,
  ServerMessages_Type_RESULTSET_ROW = 13,
  ServerMessages_Type_RESULTSET_FETCH_DONE = 14,
  ServerMessages_Type_RESULTSET_FETCH_SUSPENDED = 15,
  ServerMessages_Type_RESULTSET_FETCH_DONE_MORE_RESULTSETS = 16,
  ServerMessages_Type_SQL_STMT_EXECUTE_OK = 17,
  ServerMessages_Type_RESULTSET_FETCH_DONE_MORE_OUT_PARAMS = 18,
  ServerMessages_Type_COMPRESSION = 19
};
bool ServerMessages_Type_IsValid(int value);
constexpr ServerMessages_Type ServerMessages_Type_Type_MIN = ServerMessages_Type_OK;
constexpr ServerMessages_Type ServerMessages_Type_Type_MAX = ServerMessages_Type_COMPRESSION;
constexpr int ServerMessages_Type_Type_ARRAYSIZE = ServerMessages_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ServerMessages_Type_descriptor();
template<typename T>
inline const std::string& ServerMessages_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ServerMessages_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ServerMessages_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ServerMessages_Type_descriptor(), enum_t_value);
}
inline bool ServerMessages_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ServerMessages_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ServerMessages_Type>(
    ServerMessages_Type_descriptor(), name, value);
}
enum Error_Severity : int {
  Error_Severity_ERROR = 0,
  Error_Severity_FATAL = 1
};
bool Error_Severity_IsValid(int value);
constexpr Error_Severity Error_Severity_Severity_MIN = Error_Severity_ERROR;
constexpr Error_Severity Error_Severity_Severity_MAX = Error_Severity_FATAL;
constexpr int Error_Severity_Severity_ARRAYSIZE = Error_Severity_Severity_MAX + 1;

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

class ClientMessages final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:Mysqlx.ClientMessages) */ {
 public:
  inline ClientMessages() : ClientMessages(nullptr) {}
  explicit PROTOBUF_CONSTEXPR ClientMessages(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 ClientMessages& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClientMessages* internal_default_instance() {
    return reinterpret_cast<const ClientMessages*>(
               &_ClientMessages_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

  ClientMessages* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClientMessages>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const ClientMessages& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const ClientMessages& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.ClientMessages";
  }
  protected:
  explicit ClientMessages(::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 ClientMessages_Type Type;
  static constexpr Type CON_CAPABILITIES_GET =
    ClientMessages_Type_CON_CAPABILITIES_GET;
  static constexpr Type CON_CAPABILITIES_SET =
    ClientMessages_Type_CON_CAPABILITIES_SET;
  static constexpr Type CON_CLOSE =
    ClientMessages_Type_CON_CLOSE;
  static constexpr Type SESS_AUTHENTICATE_START =
    ClientMessages_Type_SESS_AUTHENTICATE_START;
  static constexpr Type SESS_AUTHENTICATE_CONTINUE =
    ClientMessages_Type_SESS_AUTHENTICATE_CONTINUE;
  static constexpr Type SESS_RESET =
    ClientMessages_Type_SESS_RESET;
  static constexpr Type SESS_CLOSE =
    ClientMessages_Type_SESS_CLOSE;
  static constexpr Type SQL_STMT_EXECUTE =
    ClientMessages_Type_SQL_STMT_EXECUTE;
  static constexpr Type CRUD_FIND =
    ClientMessages_Type_CRUD_FIND;
  static constexpr Type CRUD_INSERT =
    ClientMessages_Type_CRUD_INSERT;
  static constexpr Type CRUD_UPDATE =
    ClientMessages_Type_CRUD_UPDATE;
  static constexpr Type CRUD_DELETE =
    ClientMessages_Type_CRUD_DELETE;
  static constexpr Type EXPECT_OPEN =
    ClientMessages_Type_EXPECT_OPEN;
  static constexpr Type EXPECT_CLOSE =
    ClientMessages_Type_EXPECT_CLOSE;
  static constexpr Type CRUD_CREATE_VIEW =
    ClientMessages_Type_CRUD_CREATE_VIEW;
  static constexpr Type CRUD_MODIFY_VIEW =
    ClientMessages_Type_CRUD_MODIFY_VIEW;
  static constexpr Type CRUD_DROP_VIEW =
    ClientMessages_Type_CRUD_DROP_VIEW;
  static constexpr Type PREPARE_PREPARE =
    ClientMessages_Type_PREPARE_PREPARE;
  static constexpr Type PREPARE_EXECUTE =
    ClientMessages_Type_PREPARE_EXECUTE;
  static constexpr Type PREPARE_DEALLOCATE =
    ClientMessages_Type_PREPARE_DEALLOCATE;
  static constexpr Type CURSOR_OPEN =
    ClientMessages_Type_CURSOR_OPEN;
  static constexpr Type CURSOR_CLOSE =
    ClientMessages_Type_CURSOR_CLOSE;
  static constexpr Type CURSOR_FETCH =
    ClientMessages_Type_CURSOR_FETCH;
  static constexpr Type COMPRESSION =
    ClientMessages_Type_COMPRESSION;
  static inline bool Type_IsValid(int value) {
    return ClientMessages_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    ClientMessages_Type_Type_MIN;
  static constexpr Type Type_MAX =
    ClientMessages_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    ClientMessages_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return ClientMessages_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return ClientMessages_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return ClientMessages_Type_Parse(name, value);
  }

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

  // @@protoc_insertion_point(class_scope:Mysqlx.ClientMessages)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_mysqlx_2eproto;
};
// -------------------------------------------------------------------

class ServerMessages final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:Mysqlx.ServerMessages) */ {
 public:
  inline ServerMessages() : ServerMessages(nullptr) {}
  explicit PROTOBUF_CONSTEXPR ServerMessages(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 ServerMessages& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerMessages* internal_default_instance() {
    return reinterpret_cast<const ServerMessages*>(
               &_ServerMessages_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

  ServerMessages* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ServerMessages>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const ServerMessages& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const ServerMessages& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.ServerMessages";
  }
  protected:
  explicit ServerMessages(::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 ServerMessages_Type Type;
  static constexpr Type OK =
    ServerMessages_Type_OK;
  static constexpr Type ERROR =
    ServerMessages_Type_ERROR;
  static constexpr Type CONN_CAPABILITIES =
    ServerMessages_Type_CONN_CAPABILITIES;
  static constexpr Type SESS_AUTHENTICATE_CONTINUE =
    ServerMessages_Type_SESS_AUTHENTICATE_CONTINUE;
  static constexpr Type SESS_AUTHENTICATE_OK =
    ServerMessages_Type_SESS_AUTHENTICATE_OK;
  static constexpr Type NOTICE =
    ServerMessages_Type_NOTICE;
  static constexpr Type RESULTSET_COLUMN_META_DATA =
    ServerMessages_Type_RESULTSET_COLUMN_META_DATA;
  static constexpr Type RESULTSET_ROW =
    ServerMessages_Type_RESULTSET_ROW;
  static constexpr Type RESULTSET_FETCH_DONE =
    ServerMessages_Type_RESULTSET_FETCH_DONE;
  static constexpr Type RESULTSET_FETCH_SUSPENDED =
    ServerMessages_Type_RESULTSET_FETCH_SUSPENDED;
  static constexpr Type RESULTSET_FETCH_DONE_MORE_RESULTSETS =
    ServerMessages_Type_RESULTSET_FETCH_DONE_MORE_RESULTSETS;
  static constexpr Type SQL_STMT_EXECUTE_OK =
    ServerMessages_Type_SQL_STMT_EXECUTE_OK;
  static constexpr Type RESULTSET_FETCH_DONE_MORE_OUT_PARAMS =
    ServerMessages_Type_RESULTSET_FETCH_DONE_MORE_OUT_PARAMS;
  static constexpr Type COMPRESSION =
    ServerMessages_Type_COMPRESSION;
  static inline bool Type_IsValid(int value) {
    return ServerMessages_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    ServerMessages_Type_Type_MIN;
  static constexpr Type Type_MAX =
    ServerMessages_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    ServerMessages_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return ServerMessages_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return ServerMessages_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return ServerMessages_Type_Parse(name, value);
  }

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

  // @@protoc_insertion_point(class_scope:Mysqlx.ServerMessages)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_mysqlx_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 Ok& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ok* internal_default_instance() {
    return reinterpret_cast<const Ok*>(
               &_Ok_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

  Ok* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ok>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Ok& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Ok& from) {
    Ok::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Ok* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Ok";
  }
  protected:
  explicit Ok(::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 {
    kMsgFieldNumber = 1,
  };
  // optional string msg = 1;
  bool has_msg() const;
  private:
  bool _internal_has_msg() const;
  public:
  void clear_msg();
  const std::string& msg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msg();
  PROTOBUF_NODISCARD std::string* release_msg();
  void set_allocated_msg(std::string* msg);
  private:
  const std::string& _internal_msg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
  std::string* _internal_mutable_msg();
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Ok)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 Error& default_instance() {
    return *internal_default_instance();
  }
  static inline const Error* internal_default_instance() {
    return reinterpret_cast<const Error*>(
               &_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

  Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Error>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Error& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Error& from) {
    Error::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Error";
  }
  protected:
  explicit Error(::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 Error_Severity Severity;
  static constexpr Severity ERROR =
    Error_Severity_ERROR;
  static constexpr Severity FATAL =
    Error_Severity_FATAL;
  static inline bool Severity_IsValid(int value) {
    return Error_Severity_IsValid(value);
  }
  static constexpr Severity Severity_MIN =
    Error_Severity_Severity_MIN;
  static constexpr Severity Severity_MAX =
    Error_Severity_Severity_MAX;
  static constexpr int Severity_ARRAYSIZE =
    Error_Severity_Severity_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Severity_descriptor() {
    return Error_Severity_descriptor();
  }
  template<typename T>
  static inline const std::string& Severity_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Severity>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Severity_Name.");
    return Error_Severity_Name(enum_t_value);
  }
  static inline bool Severity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Severity* value) {
    return Error_Severity_Parse(name, value);
  }

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

  enum : int {
    kMsgFieldNumber = 3,
    kSqlStateFieldNumber = 4,
    kSeverityFieldNumber = 1,
    kCodeFieldNumber = 2,
  };
  // required string msg = 3;
  bool has_msg() const;
  private:
  bool _internal_has_msg() const;
  public:
  void clear_msg();
  const std::string& msg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msg();
  PROTOBUF_NODISCARD std::string* release_msg();
  void set_allocated_msg(std::string* msg);
  private:
  const std::string& _internal_msg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
  std::string* _internal_mutable_msg();
  public:

  // required string sql_state = 4;
  bool has_sql_state() const;
  private:
  bool _internal_has_sql_state() const;
  public:
  void clear_sql_state();
  const std::string& sql_state() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sql_state(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sql_state();
  PROTOBUF_NODISCARD std::string* release_sql_state();
  void set_allocated_sql_state(std::string* sql_state);
  private:
  const std::string& _internal_sql_state() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sql_state(const std::string& value);
  std::string* _internal_mutable_sql_state();
  public:

  // optional .Mysqlx.Error.Severity severity = 1 [default = ERROR];
  bool has_severity() const;
  private:
  bool _internal_has_severity() const;
  public:
  void clear_severity();
  ::Mysqlx::Error_Severity severity() const;
  void set_severity(::Mysqlx::Error_Severity value);
  private:
  ::Mysqlx::Error_Severity _internal_severity() const;
  void _internal_set_severity(::Mysqlx::Error_Severity value);
  public:

  // required uint32 code = 2;
  bool has_code() const;
  private:
  bool _internal_has_code() const;
  public:
  void clear_code();
  uint32_t code() const;
  void set_code(uint32_t value);
  private:
  uint32_t _internal_code() const;
  void _internal_set_code(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Error)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sql_state_;
    int severity_;
    uint32_t code_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_2eproto;
};
// ===================================================================

static const int kClientMessageIdFieldNumber = 100001;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::MessageOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::EnumTypeTraits< ::Mysqlx::ClientMessages_Type, ::Mysqlx::ClientMessages_Type_IsValid>, 14, false >
  client_message_id;
static const int kServerMessageIdFieldNumber = 100002;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::MessageOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::EnumTypeTraits< ::Mysqlx::ServerMessages_Type, ::Mysqlx::ServerMessages_Type_IsValid>, 14, false >
  server_message_id;

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

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

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

// ServerMessages

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

// Ok

// optional string msg = 1;
inline bool Ok::_internal_has_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Ok::has_msg() const {
  return _internal_has_msg();
}
inline void Ok::clear_msg() {
  _impl_.msg_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Ok::msg() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Ok.msg)
  return _internal_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ok::set_msg(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.msg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Ok.msg)
}
inline std::string* Ok::mutable_msg() {
  std::string* _s = _internal_mutable_msg();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Ok.msg)
  return _s;
}
inline const std::string& Ok::_internal_msg() const {
  return _impl_.msg_.Get();
}
inline void Ok::_internal_set_msg(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.msg_.Set(value, GetArenaForAllocation());
}
inline std::string* Ok::_internal_mutable_msg() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.msg_.Mutable(GetArenaForAllocation());
}
inline std::string* Ok::release_msg() {
  // @@protoc_insertion_point(field_release:Mysqlx.Ok.msg)
  if (!_internal_has_msg()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.msg_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.msg_.IsDefault()) {
    _impl_.msg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ok::set_allocated_msg(std::string* msg) {
  if (msg != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.msg_.SetAllocated(msg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.msg_.IsDefault()) {
    _impl_.msg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Ok.msg)
}

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

// Error

// optional .Mysqlx.Error.Severity severity = 1 [default = ERROR];
inline bool Error::_internal_has_severity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Error::has_severity() const {
  return _internal_has_severity();
}
inline void Error::clear_severity() {
  _impl_.severity_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::Mysqlx::Error_Severity Error::_internal_severity() const {
  return static_cast< ::Mysqlx::Error_Severity >(_impl_.severity_);
}
inline ::Mysqlx::Error_Severity Error::severity() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Error.severity)
  return _internal_severity();
}
inline void Error::_internal_set_severity(::Mysqlx::Error_Severity value) {
  assert(::Mysqlx::Error_Severity_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.severity_ = value;
}
inline void Error::set_severity(::Mysqlx::Error_Severity value) {
  _internal_set_severity(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Error.severity)
}

// required uint32 code = 2;
inline bool Error::_internal_has_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Error::has_code() const {
  return _internal_has_code();
}
inline void Error::clear_code() {
  _impl_.code_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Error::_internal_code() const {
  return _impl_.code_;
}
inline uint32_t Error::code() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Error.code)
  return _internal_code();
}
inline void Error::_internal_set_code(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.code_ = value;
}
inline void Error::set_code(uint32_t value) {
  _internal_set_code(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Error.code)
}

// required string sql_state = 4;
inline bool Error::_internal_has_sql_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Error::has_sql_state() const {
  return _internal_has_sql_state();
}
inline void Error::clear_sql_state() {
  _impl_.sql_state_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Error::sql_state() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Error.sql_state)
  return _internal_sql_state();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Error::set_sql_state(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.sql_state_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Error.sql_state)
}
inline std::string* Error::mutable_sql_state() {
  std::string* _s = _internal_mutable_sql_state();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Error.sql_state)
  return _s;
}
inline const std::string& Error::_internal_sql_state() const {
  return _impl_.sql_state_.Get();
}
inline void Error::_internal_set_sql_state(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.sql_state_.Set(value, GetArenaForAllocation());
}
inline std::string* Error::_internal_mutable_sql_state() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.sql_state_.Mutable(GetArenaForAllocation());
}
inline std::string* Error::release_sql_state() {
  // @@protoc_insertion_point(field_release:Mysqlx.Error.sql_state)
  if (!_internal_has_sql_state()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.sql_state_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sql_state_.IsDefault()) {
    _impl_.sql_state_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Error::set_allocated_sql_state(std::string* sql_state) {
  if (sql_state != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.sql_state_.SetAllocated(sql_state, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sql_state_.IsDefault()) {
    _impl_.sql_state_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Error.sql_state)
}

// required string msg = 3;
inline bool Error::_internal_has_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Error::has_msg() const {
  return _internal_has_msg();
}
inline void Error::clear_msg() {
  _impl_.msg_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Error::msg() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Error.msg)
  return _internal_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Error::set_msg(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.msg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Error.msg)
}
inline std::string* Error::mutable_msg() {
  std::string* _s = _internal_mutable_msg();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Error.msg)
  return _s;
}
inline const std::string& Error::_internal_msg() const {
  return _impl_.msg_.Get();
}
inline void Error::_internal_set_msg(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.msg_.Set(value, GetArenaForAllocation());
}
inline std::string* Error::_internal_mutable_msg() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.msg_.Mutable(GetArenaForAllocation());
}
inline std::string* Error::release_msg() {
  // @@protoc_insertion_point(field_release:Mysqlx.Error.msg)
  if (!_internal_has_msg()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.msg_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.msg_.IsDefault()) {
    _impl_.msg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Error::set_allocated_msg(std::string* msg) {
  if (msg != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.msg_.SetAllocated(msg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.msg_.IsDefault()) {
    _impl_.msg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Error.msg)
}

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Mysqlx

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::Mysqlx::ClientMessages_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::ClientMessages_Type>() {
  return ::Mysqlx::ClientMessages_Type_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::ServerMessages_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::ServerMessages_Type>() {
  return ::Mysqlx::ServerMessages_Type_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::Error_Severity> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Error_Severity>() {
  return ::Mysqlx::Error_Severity_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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