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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mysqlx_5fnotice_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mysqlx_5fnotice_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 "mysqlx.pb.h"
#include "mysqlx_datatypes.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mysqlx_5fnotice_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mysqlx_5fnotice_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mysqlx_5fnotice_2eproto;
namespace Mysqlx {
namespace Notice {
class Frame;
struct FrameDefaultTypeInternal;
extern FrameDefaultTypeInternal _Frame_default_instance_;
class GroupReplicationStateChanged;
struct GroupReplicationStateChangedDefaultTypeInternal;
extern GroupReplicationStateChangedDefaultTypeInternal _GroupReplicationStateChanged_default_instance_;
class ServerHello;
struct ServerHelloDefaultTypeInternal;
extern ServerHelloDefaultTypeInternal _ServerHello_default_instance_;
class SessionStateChanged;
struct SessionStateChangedDefaultTypeInternal;
extern SessionStateChangedDefaultTypeInternal _SessionStateChanged_default_instance_;
class SessionVariableChanged;
struct SessionVariableChangedDefaultTypeInternal;
extern SessionVariableChangedDefaultTypeInternal _SessionVariableChanged_default_instance_;
class Warning;
struct WarningDefaultTypeInternal;
extern WarningDefaultTypeInternal _Warning_default_instance_;
}  // namespace Notice
}  // namespace Mysqlx
PROTOBUF_NAMESPACE_OPEN
template<> ::Mysqlx::Notice::Frame* Arena::CreateMaybeMessage<::Mysqlx::Notice::Frame>(Arena*);
template<> ::Mysqlx::Notice::GroupReplicationStateChanged* Arena::CreateMaybeMessage<::Mysqlx::Notice::GroupReplicationStateChanged>(Arena*);
template<> ::Mysqlx::Notice::ServerHello* Arena::CreateMaybeMessage<::Mysqlx::Notice::ServerHello>(Arena*);
template<> ::Mysqlx::Notice::SessionStateChanged* Arena::CreateMaybeMessage<::Mysqlx::Notice::SessionStateChanged>(Arena*);
template<> ::Mysqlx::Notice::SessionVariableChanged* Arena::CreateMaybeMessage<::Mysqlx::Notice::SessionVariableChanged>(Arena*);
template<> ::Mysqlx::Notice::Warning* Arena::CreateMaybeMessage<::Mysqlx::Notice::Warning>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace Mysqlx {
namespace Notice {

enum Frame_Scope : int {
  Frame_Scope_GLOBAL = 1,
  Frame_Scope_LOCAL = 2
};
bool Frame_Scope_IsValid(int value);
constexpr Frame_Scope Frame_Scope_Scope_MIN = Frame_Scope_GLOBAL;
constexpr Frame_Scope Frame_Scope_Scope_MAX = Frame_Scope_LOCAL;
constexpr int Frame_Scope_Scope_ARRAYSIZE = Frame_Scope_Scope_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Frame_Scope_descriptor();
template<typename T>
inline const std::string& Frame_Scope_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Frame_Scope>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Frame_Scope_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Frame_Scope_descriptor(), enum_t_value);
}
inline bool Frame_Scope_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Frame_Scope* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Frame_Scope>(
    Frame_Scope_descriptor(), name, value);
}
enum Frame_Type : int {
  Frame_Type_WARNING = 1,
  Frame_Type_SESSION_VARIABLE_CHANGED = 2,
  Frame_Type_SESSION_STATE_CHANGED = 3,
  Frame_Type_GROUP_REPLICATION_STATE_CHANGED = 4,
  Frame_Type_SERVER_HELLO = 5
};
bool Frame_Type_IsValid(int value);
constexpr Frame_Type Frame_Type_Type_MIN = Frame_Type_WARNING;
constexpr Frame_Type Frame_Type_Type_MAX = Frame_Type_SERVER_HELLO;
constexpr int Frame_Type_Type_ARRAYSIZE = Frame_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Frame_Type_descriptor();
template<typename T>
inline const std::string& Frame_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Frame_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Frame_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Frame_Type_descriptor(), enum_t_value);
}
inline bool Frame_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Frame_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Frame_Type>(
    Frame_Type_descriptor(), name, value);
}
enum Warning_Level : int {
  Warning_Level_NOTE = 1,
  Warning_Level_WARNING = 2,
  Warning_Level_ERROR = 3
};
bool Warning_Level_IsValid(int value);
constexpr Warning_Level Warning_Level_Level_MIN = Warning_Level_NOTE;
constexpr Warning_Level Warning_Level_Level_MAX = Warning_Level_ERROR;
constexpr int Warning_Level_Level_ARRAYSIZE = Warning_Level_Level_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Warning_Level_descriptor();
template<typename T>
inline const std::string& Warning_Level_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Warning_Level>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Warning_Level_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Warning_Level_descriptor(), enum_t_value);
}
inline bool Warning_Level_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Warning_Level* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Warning_Level>(
    Warning_Level_descriptor(), name, value);
}
enum SessionStateChanged_Parameter : int {
  SessionStateChanged_Parameter_CURRENT_SCHEMA = 1,
  SessionStateChanged_Parameter_ACCOUNT_EXPIRED = 2,
  SessionStateChanged_Parameter_GENERATED_INSERT_ID = 3,
  SessionStateChanged_Parameter_ROWS_AFFECTED = 4,
  SessionStateChanged_Parameter_ROWS_FOUND = 5,
  SessionStateChanged_Parameter_ROWS_MATCHED = 6,
  SessionStateChanged_Parameter_TRX_COMMITTED = 7,
  SessionStateChanged_Parameter_TRX_ROLLEDBACK = 9,
  SessionStateChanged_Parameter_PRODUCED_MESSAGE = 10,
  SessionStateChanged_Parameter_CLIENT_ID_ASSIGNED = 11,
  SessionStateChanged_Parameter_GENERATED_DOCUMENT_IDS = 12
};
bool SessionStateChanged_Parameter_IsValid(int value);
constexpr SessionStateChanged_Parameter SessionStateChanged_Parameter_Parameter_MIN = SessionStateChanged_Parameter_CURRENT_SCHEMA;
constexpr SessionStateChanged_Parameter SessionStateChanged_Parameter_Parameter_MAX = SessionStateChanged_Parameter_GENERATED_DOCUMENT_IDS;
constexpr int SessionStateChanged_Parameter_Parameter_ARRAYSIZE = SessionStateChanged_Parameter_Parameter_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SessionStateChanged_Parameter_descriptor();
template<typename T>
inline const std::string& SessionStateChanged_Parameter_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SessionStateChanged_Parameter>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SessionStateChanged_Parameter_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SessionStateChanged_Parameter_descriptor(), enum_t_value);
}
inline bool SessionStateChanged_Parameter_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SessionStateChanged_Parameter* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SessionStateChanged_Parameter>(
    SessionStateChanged_Parameter_descriptor(), name, value);
}
enum GroupReplicationStateChanged_Type : int {
  GroupReplicationStateChanged_Type_MEMBERSHIP_QUORUM_LOSS = 1,
  GroupReplicationStateChanged_Type_MEMBERSHIP_VIEW_CHANGE = 2,
  GroupReplicationStateChanged_Type_MEMBER_ROLE_CHANGE = 3,
  GroupReplicationStateChanged_Type_MEMBER_STATE_CHANGE = 4
};
bool GroupReplicationStateChanged_Type_IsValid(int value);
constexpr GroupReplicationStateChanged_Type GroupReplicationStateChanged_Type_Type_MIN = GroupReplicationStateChanged_Type_MEMBERSHIP_QUORUM_LOSS;
constexpr GroupReplicationStateChanged_Type GroupReplicationStateChanged_Type_Type_MAX = GroupReplicationStateChanged_Type_MEMBER_STATE_CHANGE;
constexpr int GroupReplicationStateChanged_Type_Type_ARRAYSIZE = GroupReplicationStateChanged_Type_Type_MAX + 1;

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Notice.Frame";
  }
  protected:
  explicit Frame(::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 Frame_Scope Scope;
  static constexpr Scope GLOBAL =
    Frame_Scope_GLOBAL;
  static constexpr Scope LOCAL =
    Frame_Scope_LOCAL;
  static inline bool Scope_IsValid(int value) {
    return Frame_Scope_IsValid(value);
  }
  static constexpr Scope Scope_MIN =
    Frame_Scope_Scope_MIN;
  static constexpr Scope Scope_MAX =
    Frame_Scope_Scope_MAX;
  static constexpr int Scope_ARRAYSIZE =
    Frame_Scope_Scope_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Scope_descriptor() {
    return Frame_Scope_descriptor();
  }
  template<typename T>
  static inline const std::string& Scope_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Scope>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Scope_Name.");
    return Frame_Scope_Name(enum_t_value);
  }
  static inline bool Scope_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Scope* value) {
    return Frame_Scope_Parse(name, value);
  }

  typedef Frame_Type Type;
  static constexpr Type WARNING =
    Frame_Type_WARNING;
  static constexpr Type SESSION_VARIABLE_CHANGED =
    Frame_Type_SESSION_VARIABLE_CHANGED;
  static constexpr Type SESSION_STATE_CHANGED =
    Frame_Type_SESSION_STATE_CHANGED;
  static constexpr Type GROUP_REPLICATION_STATE_CHANGED =
    Frame_Type_GROUP_REPLICATION_STATE_CHANGED;
  static constexpr Type SERVER_HELLO =
    Frame_Type_SERVER_HELLO;
  static inline bool Type_IsValid(int value) {
    return Frame_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Frame_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Frame_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Frame_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Frame_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 Frame_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Frame_Type_Parse(name, value);
  }

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

  enum : int {
    kPayloadFieldNumber = 3,
    kTypeFieldNumber = 1,
    kScopeFieldNumber = 2,
  };
  // optional bytes payload = 3;
  bool has_payload() const;
  private:
  bool _internal_has_payload() const;
  public:
  void clear_payload();
  const std::string& payload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_payload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // required uint32 type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  uint32_t type() const;
  void set_type(uint32_t value);
  private:
  uint32_t _internal_type() const;
  void _internal_set_type(uint32_t value);
  public:

  // optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL];
  bool has_scope() const;
  private:
  bool _internal_has_scope() const;
  public:
  void clear_scope();
  ::Mysqlx::Notice::Frame_Scope scope() const;
  void set_scope(::Mysqlx::Notice::Frame_Scope value);
  private:
  ::Mysqlx::Notice::Frame_Scope _internal_scope() const;
  void _internal_set_scope(::Mysqlx::Notice::Frame_Scope value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Notice.Frame)
 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 payload_;
    uint32_t type_;
    int scope_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fnotice_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Notice.Warning";
  }
  protected:
  explicit Warning(::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 Warning_Level Level;
  static constexpr Level NOTE =
    Warning_Level_NOTE;
  static constexpr Level WARNING =
    Warning_Level_WARNING;
  static constexpr Level ERROR =
    Warning_Level_ERROR;
  static inline bool Level_IsValid(int value) {
    return Warning_Level_IsValid(value);
  }
  static constexpr Level Level_MIN =
    Warning_Level_Level_MIN;
  static constexpr Level Level_MAX =
    Warning_Level_Level_MAX;
  static constexpr int Level_ARRAYSIZE =
    Warning_Level_Level_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Level_descriptor() {
    return Warning_Level_descriptor();
  }
  template<typename T>
  static inline const std::string& Level_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Level>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Level_Name.");
    return Warning_Level_Name(enum_t_value);
  }
  static inline bool Level_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Level* value) {
    return Warning_Level_Parse(name, value);
  }

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

  enum : int {
    kMsgFieldNumber = 3,
    kCodeFieldNumber = 2,
    kLevelFieldNumber = 1,
  };
  // 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 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:

  // optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING];
  bool has_level() const;
  private:
  bool _internal_has_level() const;
  public:
  void clear_level();
  ::Mysqlx::Notice::Warning_Level level() const;
  void set_level(::Mysqlx::Notice::Warning_Level value);
  private:
  ::Mysqlx::Notice::Warning_Level _internal_level() const;
  void _internal_set_level(::Mysqlx::Notice::Warning_Level value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Notice.Warning)
 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_;
    uint32_t code_;
    int level_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fnotice_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Notice.SessionVariableChanged";
  }
  protected:
  explicit SessionVariableChanged(::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 {
    kParamFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // required string param = 1;
  bool has_param() const;
  private:
  bool _internal_has_param() const;
  public:
  void clear_param();
  const std::string& param() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_param(ArgT0&& arg0, ArgT... args);
  std::string* mutable_param();
  PROTOBUF_NODISCARD std::string* release_param();
  void set_allocated_param(std::string* param);
  private:
  const std::string& _internal_param() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_param(const std::string& value);
  std::string* _internal_mutable_param();
  public:

  // optional .Mysqlx.Datatypes.Scalar value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::Mysqlx::Datatypes::Scalar& value() const;
  PROTOBUF_NODISCARD ::Mysqlx::Datatypes::Scalar* release_value();
  ::Mysqlx::Datatypes::Scalar* mutable_value();
  void set_allocated_value(::Mysqlx::Datatypes::Scalar* value);
  private:
  const ::Mysqlx::Datatypes::Scalar& _internal_value() const;
  ::Mysqlx::Datatypes::Scalar* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::Mysqlx::Datatypes::Scalar* value);
  ::Mysqlx::Datatypes::Scalar* unsafe_arena_release_value();

  // @@protoc_insertion_point(class_scope:Mysqlx.Notice.SessionVariableChanged)
 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 param_;
    ::Mysqlx::Datatypes::Scalar* value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fnotice_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Notice.SessionStateChanged";
  }
  protected:
  explicit SessionStateChanged(::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 SessionStateChanged_Parameter Parameter;
  static constexpr Parameter CURRENT_SCHEMA =
    SessionStateChanged_Parameter_CURRENT_SCHEMA;
  static constexpr Parameter ACCOUNT_EXPIRED =
    SessionStateChanged_Parameter_ACCOUNT_EXPIRED;
  static constexpr Parameter GENERATED_INSERT_ID =
    SessionStateChanged_Parameter_GENERATED_INSERT_ID;
  static constexpr Parameter ROWS_AFFECTED =
    SessionStateChanged_Parameter_ROWS_AFFECTED;
  static constexpr Parameter ROWS_FOUND =
    SessionStateChanged_Parameter_ROWS_FOUND;
  static constexpr Parameter ROWS_MATCHED =
    SessionStateChanged_Parameter_ROWS_MATCHED;
  static constexpr Parameter TRX_COMMITTED =
    SessionStateChanged_Parameter_TRX_COMMITTED;
  static constexpr Parameter TRX_ROLLEDBACK =
    SessionStateChanged_Parameter_TRX_ROLLEDBACK;
  static constexpr Parameter PRODUCED_MESSAGE =
    SessionStateChanged_Parameter_PRODUCED_MESSAGE;
  static constexpr Parameter CLIENT_ID_ASSIGNED =
    SessionStateChanged_Parameter_CLIENT_ID_ASSIGNED;
  static constexpr Parameter GENERATED_DOCUMENT_IDS =
    SessionStateChanged_Parameter_GENERATED_DOCUMENT_IDS;
  static inline bool Parameter_IsValid(int value) {
    return SessionStateChanged_Parameter_IsValid(value);
  }
  static constexpr Parameter Parameter_MIN =
    SessionStateChanged_Parameter_Parameter_MIN;
  static constexpr Parameter Parameter_MAX =
    SessionStateChanged_Parameter_Parameter_MAX;
  static constexpr int Parameter_ARRAYSIZE =
    SessionStateChanged_Parameter_Parameter_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Parameter_descriptor() {
    return SessionStateChanged_Parameter_descriptor();
  }
  template<typename T>
  static inline const std::string& Parameter_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Parameter>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Parameter_Name.");
    return SessionStateChanged_Parameter_Name(enum_t_value);
  }
  static inline bool Parameter_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Parameter* value) {
    return SessionStateChanged_Parameter_Parse(name, value);
  }

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

  enum : int {
    kValueFieldNumber = 2,
    kParamFieldNumber = 1,
  };
  // repeated .Mysqlx.Datatypes.Scalar value = 2;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  ::Mysqlx::Datatypes::Scalar* mutable_value(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Scalar >*
      mutable_value();
  private:
  const ::Mysqlx::Datatypes::Scalar& _internal_value(int index) const;
  ::Mysqlx::Datatypes::Scalar* _internal_add_value();
  public:
  const ::Mysqlx::Datatypes::Scalar& value(int index) const;
  ::Mysqlx::Datatypes::Scalar* add_value();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Scalar >&
      value() const;

  // required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1;
  bool has_param() const;
  private:
  bool _internal_has_param() const;
  public:
  void clear_param();
  ::Mysqlx::Notice::SessionStateChanged_Parameter param() const;
  void set_param(::Mysqlx::Notice::SessionStateChanged_Parameter value);
  private:
  ::Mysqlx::Notice::SessionStateChanged_Parameter _internal_param() const;
  void _internal_set_param(::Mysqlx::Notice::SessionStateChanged_Parameter value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Notice.SessionStateChanged)
 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::RepeatedPtrField< ::Mysqlx::Datatypes::Scalar > value_;
    int param_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fnotice_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Notice.GroupReplicationStateChanged";
  }
  protected:
  explicit GroupReplicationStateChanged(::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 GroupReplicationStateChanged_Type Type;
  static constexpr Type MEMBERSHIP_QUORUM_LOSS =
    GroupReplicationStateChanged_Type_MEMBERSHIP_QUORUM_LOSS;
  static constexpr Type MEMBERSHIP_VIEW_CHANGE =
    GroupReplicationStateChanged_Type_MEMBERSHIP_VIEW_CHANGE;
  static constexpr Type MEMBER_ROLE_CHANGE =
    GroupReplicationStateChanged_Type_MEMBER_ROLE_CHANGE;
  static constexpr Type MEMBER_STATE_CHANGE =
    GroupReplicationStateChanged_Type_MEMBER_STATE_CHANGE;
  static inline bool Type_IsValid(int value) {
    return GroupReplicationStateChanged_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    GroupReplicationStateChanged_Type_Type_MIN;
  static constexpr Type Type_MAX =
    GroupReplicationStateChanged_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    GroupReplicationStateChanged_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return GroupReplicationStateChanged_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 GroupReplicationStateChanged_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return GroupReplicationStateChanged_Type_Parse(name, value);
  }

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

  enum : int {
    kViewIdFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // optional string view_id = 2;
  bool has_view_id() const;
  private:
  bool _internal_has_view_id() const;
  public:
  void clear_view_id();
  const std::string& view_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_view_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_view_id();
  PROTOBUF_NODISCARD std::string* release_view_id();
  void set_allocated_view_id(std::string* view_id);
  private:
  const std::string& _internal_view_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_view_id(const std::string& value);
  std::string* _internal_mutable_view_id();
  public:

  // required uint32 type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  uint32_t type() const;
  void set_type(uint32_t value);
  private:
  uint32_t _internal_type() const;
  void _internal_set_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Notice.GroupReplicationStateChanged)
 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 view_id_;
    uint32_t type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fnotice_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  ServerHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ServerHello>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const ServerHello& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const ServerHello& 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.Notice.ServerHello";
  }
  protected:
  explicit ServerHello(::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 -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:Mysqlx.Notice.ServerHello)
 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_5fnotice_2eproto;
};
// ===================================================================


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

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

// required uint32 type = 1;
inline bool Frame::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Frame::has_type() const {
  return _internal_has_type();
}
inline void Frame::clear_type() {
  _impl_.type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t Frame::_internal_type() const {
  return _impl_.type_;
}
inline uint32_t Frame::type() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.Frame.type)
  return _internal_type();
}
inline void Frame::_internal_set_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_ = value;
}
inline void Frame::set_type(uint32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Notice.Frame.type)
}

// optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL];
inline bool Frame::_internal_has_scope() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Frame::has_scope() const {
  return _internal_has_scope();
}
inline void Frame::clear_scope() {
  _impl_.scope_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::Mysqlx::Notice::Frame_Scope Frame::_internal_scope() const {
  return static_cast< ::Mysqlx::Notice::Frame_Scope >(_impl_.scope_);
}
inline ::Mysqlx::Notice::Frame_Scope Frame::scope() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.Frame.scope)
  return _internal_scope();
}
inline void Frame::_internal_set_scope(::Mysqlx::Notice::Frame_Scope value) {
  assert(::Mysqlx::Notice::Frame_Scope_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.scope_ = value;
}
inline void Frame::set_scope(::Mysqlx::Notice::Frame_Scope value) {
  _internal_set_scope(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Notice.Frame.scope)
}

// optional bytes payload = 3;
inline bool Frame::_internal_has_payload() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Frame::has_payload() const {
  return _internal_has_payload();
}
inline void Frame::clear_payload() {
  _impl_.payload_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Frame::payload() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.Frame.payload)
  return _internal_payload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Frame::set_payload(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Notice.Frame.payload)
}
inline std::string* Frame::mutable_payload() {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Notice.Frame.payload)
  return _s;
}
inline const std::string& Frame::_internal_payload() const {
  return _impl_.payload_.Get();
}
inline void Frame::_internal_set_payload(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.payload_.Set(value, GetArenaForAllocation());
}
inline std::string* Frame::_internal_mutable_payload() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.payload_.Mutable(GetArenaForAllocation());
}
inline std::string* Frame::release_payload() {
  // @@protoc_insertion_point(field_release:Mysqlx.Notice.Frame.payload)
  if (!_internal_has_payload()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.payload_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Frame::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.payload_.SetAllocated(payload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Notice.Frame.payload)
}

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

// Warning

// optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING];
inline bool Warning::_internal_has_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Warning::has_level() const {
  return _internal_has_level();
}
inline void Warning::clear_level() {
  _impl_.level_ = 2;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::Mysqlx::Notice::Warning_Level Warning::_internal_level() const {
  return static_cast< ::Mysqlx::Notice::Warning_Level >(_impl_.level_);
}
inline ::Mysqlx::Notice::Warning_Level Warning::level() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.Warning.level)
  return _internal_level();
}
inline void Warning::_internal_set_level(::Mysqlx::Notice::Warning_Level value) {
  assert(::Mysqlx::Notice::Warning_Level_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.level_ = value;
}
inline void Warning::set_level(::Mysqlx::Notice::Warning_Level value) {
  _internal_set_level(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Notice.Warning.level)
}

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

// required string msg = 3;
inline bool Warning::_internal_has_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Warning::has_msg() const {
  return _internal_has_msg();
}
inline void Warning::clear_msg() {
  _impl_.msg_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Warning::msg() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.Warning.msg)
  return _internal_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Warning::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.Notice.Warning.msg)
}
inline std::string* Warning::mutable_msg() {
  std::string* _s = _internal_mutable_msg();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Notice.Warning.msg)
  return _s;
}
inline const std::string& Warning::_internal_msg() const {
  return _impl_.msg_.Get();
}
inline void Warning::_internal_set_msg(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.msg_.Set(value, GetArenaForAllocation());
}
inline std::string* Warning::_internal_mutable_msg() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.msg_.Mutable(GetArenaForAllocation());
}
inline std::string* Warning::release_msg() {
  // @@protoc_insertion_point(field_release:Mysqlx.Notice.Warning.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 Warning::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.Notice.Warning.msg)
}

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

// SessionVariableChanged

// required string param = 1;
inline bool SessionVariableChanged::_internal_has_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SessionVariableChanged::has_param() const {
  return _internal_has_param();
}
inline void SessionVariableChanged::clear_param() {
  _impl_.param_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SessionVariableChanged::param() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.SessionVariableChanged.param)
  return _internal_param();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SessionVariableChanged::set_param(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.param_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Notice.SessionVariableChanged.param)
}
inline std::string* SessionVariableChanged::mutable_param() {
  std::string* _s = _internal_mutable_param();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Notice.SessionVariableChanged.param)
  return _s;
}
inline const std::string& SessionVariableChanged::_internal_param() const {
  return _impl_.param_.Get();
}
inline void SessionVariableChanged::_internal_set_param(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.param_.Set(value, GetArenaForAllocation());
}
inline std::string* SessionVariableChanged::_internal_mutable_param() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.param_.Mutable(GetArenaForAllocation());
}
inline std::string* SessionVariableChanged::release_param() {
  // @@protoc_insertion_point(field_release:Mysqlx.Notice.SessionVariableChanged.param)
  if (!_internal_has_param()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.param_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param_.IsDefault()) {
    _impl_.param_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SessionVariableChanged::set_allocated_param(std::string* param) {
  if (param != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.param_.SetAllocated(param, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param_.IsDefault()) {
    _impl_.param_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Notice.SessionVariableChanged.param)
}

// optional .Mysqlx.Datatypes.Scalar value = 2;
inline bool SessionVariableChanged::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline bool SessionVariableChanged::has_value() const {
  return _internal_has_value();
}
inline const ::Mysqlx::Datatypes::Scalar& SessionVariableChanged::_internal_value() const {
  const ::Mysqlx::Datatypes::Scalar* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::Mysqlx::Datatypes::Scalar&>(
      ::Mysqlx::Datatypes::_Scalar_default_instance_);
}
inline const ::Mysqlx::Datatypes::Scalar& SessionVariableChanged::value() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.SessionVariableChanged.value)
  return _internal_value();
}
inline void SessionVariableChanged::unsafe_arena_set_allocated_value(
    ::Mysqlx::Datatypes::Scalar* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = value;
  if (value) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Mysqlx.Notice.SessionVariableChanged.value)
}
inline ::Mysqlx::Datatypes::Scalar* SessionVariableChanged::release_value() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Mysqlx::Datatypes::Scalar* temp = _impl_.value_;
  _impl_.value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::Mysqlx::Datatypes::Scalar* SessionVariableChanged::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:Mysqlx.Notice.SessionVariableChanged.value)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Mysqlx::Datatypes::Scalar* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::Mysqlx::Datatypes::Scalar* SessionVariableChanged::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::Mysqlx::Datatypes::Scalar>(GetArenaForAllocation());
    _impl_.value_ = p;
  }
  return _impl_.value_;
}
inline ::Mysqlx::Datatypes::Scalar* SessionVariableChanged::mutable_value() {
  ::Mysqlx::Datatypes::Scalar* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Notice.SessionVariableChanged.value)
  return _msg;
}
inline void SessionVariableChanged::set_allocated_value(::Mysqlx::Datatypes::Scalar* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value));
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.value_ = value;
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Notice.SessionVariableChanged.value)
}

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

// SessionStateChanged

// required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1;
inline bool SessionStateChanged::_internal_has_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SessionStateChanged::has_param() const {
  return _internal_has_param();
}
inline void SessionStateChanged::clear_param() {
  _impl_.param_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::Mysqlx::Notice::SessionStateChanged_Parameter SessionStateChanged::_internal_param() const {
  return static_cast< ::Mysqlx::Notice::SessionStateChanged_Parameter >(_impl_.param_);
}
inline ::Mysqlx::Notice::SessionStateChanged_Parameter SessionStateChanged::param() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.SessionStateChanged.param)
  return _internal_param();
}
inline void SessionStateChanged::_internal_set_param(::Mysqlx::Notice::SessionStateChanged_Parameter value) {
  assert(::Mysqlx::Notice::SessionStateChanged_Parameter_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.param_ = value;
}
inline void SessionStateChanged::set_param(::Mysqlx::Notice::SessionStateChanged_Parameter value) {
  _internal_set_param(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Notice.SessionStateChanged.param)
}

// repeated .Mysqlx.Datatypes.Scalar value = 2;
inline int SessionStateChanged::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int SessionStateChanged::value_size() const {
  return _internal_value_size();
}
inline ::Mysqlx::Datatypes::Scalar* SessionStateChanged::mutable_value(int index) {
  // @@protoc_insertion_point(field_mutable:Mysqlx.Notice.SessionStateChanged.value)
  return _impl_.value_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Scalar >*
SessionStateChanged::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:Mysqlx.Notice.SessionStateChanged.value)
  return &_impl_.value_;
}
inline const ::Mysqlx::Datatypes::Scalar& SessionStateChanged::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline const ::Mysqlx::Datatypes::Scalar& SessionStateChanged::value(int index) const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.SessionStateChanged.value)
  return _internal_value(index);
}
inline ::Mysqlx::Datatypes::Scalar* SessionStateChanged::_internal_add_value() {
  return _impl_.value_.Add();
}
inline ::Mysqlx::Datatypes::Scalar* SessionStateChanged::add_value() {
  ::Mysqlx::Datatypes::Scalar* _add = _internal_add_value();
  // @@protoc_insertion_point(field_add:Mysqlx.Notice.SessionStateChanged.value)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Scalar >&
SessionStateChanged::value() const {
  // @@protoc_insertion_point(field_list:Mysqlx.Notice.SessionStateChanged.value)
  return _impl_.value_;
}

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

// GroupReplicationStateChanged

// required uint32 type = 1;
inline bool GroupReplicationStateChanged::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GroupReplicationStateChanged::has_type() const {
  return _internal_has_type();
}
inline void GroupReplicationStateChanged::clear_type() {
  _impl_.type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t GroupReplicationStateChanged::_internal_type() const {
  return _impl_.type_;
}
inline uint32_t GroupReplicationStateChanged::type() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.GroupReplicationStateChanged.type)
  return _internal_type();
}
inline void GroupReplicationStateChanged::_internal_set_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_ = value;
}
inline void GroupReplicationStateChanged::set_type(uint32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Notice.GroupReplicationStateChanged.type)
}

// optional string view_id = 2;
inline bool GroupReplicationStateChanged::_internal_has_view_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GroupReplicationStateChanged::has_view_id() const {
  return _internal_has_view_id();
}
inline void GroupReplicationStateChanged::clear_view_id() {
  _impl_.view_id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GroupReplicationStateChanged::view_id() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Notice.GroupReplicationStateChanged.view_id)
  return _internal_view_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupReplicationStateChanged::set_view_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.view_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Notice.GroupReplicationStateChanged.view_id)
}
inline std::string* GroupReplicationStateChanged::mutable_view_id() {
  std::string* _s = _internal_mutable_view_id();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Notice.GroupReplicationStateChanged.view_id)
  return _s;
}
inline const std::string& GroupReplicationStateChanged::_internal_view_id() const {
  return _impl_.view_id_.Get();
}
inline void GroupReplicationStateChanged::_internal_set_view_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.view_id_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupReplicationStateChanged::_internal_mutable_view_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.view_id_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupReplicationStateChanged::release_view_id() {
  // @@protoc_insertion_point(field_release:Mysqlx.Notice.GroupReplicationStateChanged.view_id)
  if (!_internal_has_view_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.view_id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.view_id_.IsDefault()) {
    _impl_.view_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupReplicationStateChanged::set_allocated_view_id(std::string* view_id) {
  if (view_id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.view_id_.SetAllocated(view_id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.view_id_.IsDefault()) {
    _impl_.view_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Notice.GroupReplicationStateChanged.view_id)
}

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

// ServerHello

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Notice
}  // namespace Mysqlx

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::Mysqlx::Notice::Frame_Scope> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Notice::Frame_Scope>() {
  return ::Mysqlx::Notice::Frame_Scope_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::Notice::Frame_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Notice::Frame_Type>() {
  return ::Mysqlx::Notice::Frame_Type_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::Notice::Warning_Level> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Notice::Warning_Level>() {
  return ::Mysqlx::Notice::Warning_Level_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::Notice::SessionStateChanged_Parameter> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Notice::SessionStateChanged_Parameter>() {
  return ::Mysqlx::Notice::SessionStateChanged_Parameter_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::Notice::GroupReplicationStateChanged_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Notice::GroupReplicationStateChanged_Type>() {
  return ::Mysqlx::Notice::GroupReplicationStateChanged_Type_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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