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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mysqlx_5fexpect_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mysqlx_5fexpect_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"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mysqlx_5fexpect_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mysqlx_5fexpect_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mysqlx_5fexpect_2eproto;
namespace Mysqlx {
namespace Expect {
class Close;
struct CloseDefaultTypeInternal;
extern CloseDefaultTypeInternal _Close_default_instance_;
class Open;
struct OpenDefaultTypeInternal;
extern OpenDefaultTypeInternal _Open_default_instance_;
class Open_Condition;
struct Open_ConditionDefaultTypeInternal;
extern Open_ConditionDefaultTypeInternal _Open_Condition_default_instance_;
}  // namespace Expect
}  // namespace Mysqlx
PROTOBUF_NAMESPACE_OPEN
template<> ::Mysqlx::Expect::Close* Arena::CreateMaybeMessage<::Mysqlx::Expect::Close>(Arena*);
template<> ::Mysqlx::Expect::Open* Arena::CreateMaybeMessage<::Mysqlx::Expect::Open>(Arena*);
template<> ::Mysqlx::Expect::Open_Condition* Arena::CreateMaybeMessage<::Mysqlx::Expect::Open_Condition>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace Mysqlx {
namespace Expect {

enum Open_Condition_Key : int {
  Open_Condition_Key_EXPECT_NO_ERROR = 1,
  Open_Condition_Key_EXPECT_FIELD_EXIST = 2,
  Open_Condition_Key_EXPECT_DOCID_GENERATED = 3
};
bool Open_Condition_Key_IsValid(int value);
constexpr Open_Condition_Key Open_Condition_Key_Key_MIN = Open_Condition_Key_EXPECT_NO_ERROR;
constexpr Open_Condition_Key Open_Condition_Key_Key_MAX = Open_Condition_Key_EXPECT_DOCID_GENERATED;
constexpr int Open_Condition_Key_Key_ARRAYSIZE = Open_Condition_Key_Key_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Open_Condition_Key_descriptor();
template<typename T>
inline const std::string& Open_Condition_Key_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Open_Condition_Key>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Open_Condition_Key_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Open_Condition_Key_descriptor(), enum_t_value);
}
inline bool Open_Condition_Key_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Open_Condition_Key* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Open_Condition_Key>(
    Open_Condition_Key_descriptor(), name, value);
}
enum Open_Condition_ConditionOperation : int {
  Open_Condition_ConditionOperation_EXPECT_OP_SET = 0,
  Open_Condition_ConditionOperation_EXPECT_OP_UNSET = 1
};
bool Open_Condition_ConditionOperation_IsValid(int value);
constexpr Open_Condition_ConditionOperation Open_Condition_ConditionOperation_ConditionOperation_MIN = Open_Condition_ConditionOperation_EXPECT_OP_SET;
constexpr Open_Condition_ConditionOperation Open_Condition_ConditionOperation_ConditionOperation_MAX = Open_Condition_ConditionOperation_EXPECT_OP_UNSET;
constexpr int Open_Condition_ConditionOperation_ConditionOperation_ARRAYSIZE = Open_Condition_ConditionOperation_ConditionOperation_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Open_Condition_ConditionOperation_descriptor();
template<typename T>
inline const std::string& Open_Condition_ConditionOperation_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Open_Condition_ConditionOperation>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Open_Condition_ConditionOperation_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Open_Condition_ConditionOperation_descriptor(), enum_t_value);
}
inline bool Open_Condition_ConditionOperation_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Open_Condition_ConditionOperation* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Open_Condition_ConditionOperation>(
    Open_Condition_ConditionOperation_descriptor(), name, value);
}
enum Open_CtxOperation : int {
  Open_CtxOperation_EXPECT_CTX_COPY_PREV = 0,
  Open_CtxOperation_EXPECT_CTX_EMPTY = 1
};
bool Open_CtxOperation_IsValid(int value);
constexpr Open_CtxOperation Open_CtxOperation_CtxOperation_MIN = Open_CtxOperation_EXPECT_CTX_COPY_PREV;
constexpr Open_CtxOperation Open_CtxOperation_CtxOperation_MAX = Open_CtxOperation_EXPECT_CTX_EMPTY;
constexpr int Open_CtxOperation_CtxOperation_ARRAYSIZE = Open_CtxOperation_CtxOperation_MAX + 1;

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Expect.Open.Condition";
  }
  protected:
  explicit Open_Condition(::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 Open_Condition_Key Key;
  static constexpr Key EXPECT_NO_ERROR =
    Open_Condition_Key_EXPECT_NO_ERROR;
  static constexpr Key EXPECT_FIELD_EXIST =
    Open_Condition_Key_EXPECT_FIELD_EXIST;
  static constexpr Key EXPECT_DOCID_GENERATED =
    Open_Condition_Key_EXPECT_DOCID_GENERATED;
  static inline bool Key_IsValid(int value) {
    return Open_Condition_Key_IsValid(value);
  }
  static constexpr Key Key_MIN =
    Open_Condition_Key_Key_MIN;
  static constexpr Key Key_MAX =
    Open_Condition_Key_Key_MAX;
  static constexpr int Key_ARRAYSIZE =
    Open_Condition_Key_Key_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Key_descriptor() {
    return Open_Condition_Key_descriptor();
  }
  template<typename T>
  static inline const std::string& Key_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Key>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Key_Name.");
    return Open_Condition_Key_Name(enum_t_value);
  }
  static inline bool Key_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Key* value) {
    return Open_Condition_Key_Parse(name, value);
  }

  typedef Open_Condition_ConditionOperation ConditionOperation;
  static constexpr ConditionOperation EXPECT_OP_SET =
    Open_Condition_ConditionOperation_EXPECT_OP_SET;
  static constexpr ConditionOperation EXPECT_OP_UNSET =
    Open_Condition_ConditionOperation_EXPECT_OP_UNSET;
  static inline bool ConditionOperation_IsValid(int value) {
    return Open_Condition_ConditionOperation_IsValid(value);
  }
  static constexpr ConditionOperation ConditionOperation_MIN =
    Open_Condition_ConditionOperation_ConditionOperation_MIN;
  static constexpr ConditionOperation ConditionOperation_MAX =
    Open_Condition_ConditionOperation_ConditionOperation_MAX;
  static constexpr int ConditionOperation_ARRAYSIZE =
    Open_Condition_ConditionOperation_ConditionOperation_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ConditionOperation_descriptor() {
    return Open_Condition_ConditionOperation_descriptor();
  }
  template<typename T>
  static inline const std::string& ConditionOperation_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ConditionOperation>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ConditionOperation_Name.");
    return Open_Condition_ConditionOperation_Name(enum_t_value);
  }
  static inline bool ConditionOperation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ConditionOperation* value) {
    return Open_Condition_ConditionOperation_Parse(name, value);
  }

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

  enum : int {
    kConditionValueFieldNumber = 2,
    kConditionKeyFieldNumber = 1,
    kOpFieldNumber = 3,
  };
  // optional bytes condition_value = 2;
  bool has_condition_value() const;
  private:
  bool _internal_has_condition_value() const;
  public:
  void clear_condition_value();
  const std::string& condition_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_condition_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_condition_value();
  PROTOBUF_NODISCARD std::string* release_condition_value();
  void set_allocated_condition_value(std::string* condition_value);
  private:
  const std::string& _internal_condition_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_condition_value(const std::string& value);
  std::string* _internal_mutable_condition_value();
  public:

  // required uint32 condition_key = 1;
  bool has_condition_key() const;
  private:
  bool _internal_has_condition_key() const;
  public:
  void clear_condition_key();
  uint32_t condition_key() const;
  void set_condition_key(uint32_t value);
  private:
  uint32_t _internal_condition_key() const;
  void _internal_set_condition_key(uint32_t value);
  public:

  // optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET];
  bool has_op() const;
  private:
  bool _internal_has_op() const;
  public:
  void clear_op();
  ::Mysqlx::Expect::Open_Condition_ConditionOperation op() const;
  void set_op(::Mysqlx::Expect::Open_Condition_ConditionOperation value);
  private:
  ::Mysqlx::Expect::Open_Condition_ConditionOperation _internal_op() const;
  void _internal_set_op(::Mysqlx::Expect::Open_Condition_ConditionOperation value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Expect.Open.Condition)
 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 condition_value_;
    uint32_t condition_key_;
    int op_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fexpect_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Expect.Open";
  }
  protected:
  explicit Open(::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 Open_Condition Condition;

  typedef Open_CtxOperation CtxOperation;
  static constexpr CtxOperation EXPECT_CTX_COPY_PREV =
    Open_CtxOperation_EXPECT_CTX_COPY_PREV;
  static constexpr CtxOperation EXPECT_CTX_EMPTY =
    Open_CtxOperation_EXPECT_CTX_EMPTY;
  static inline bool CtxOperation_IsValid(int value) {
    return Open_CtxOperation_IsValid(value);
  }
  static constexpr CtxOperation CtxOperation_MIN =
    Open_CtxOperation_CtxOperation_MIN;
  static constexpr CtxOperation CtxOperation_MAX =
    Open_CtxOperation_CtxOperation_MAX;
  static constexpr int CtxOperation_ARRAYSIZE =
    Open_CtxOperation_CtxOperation_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  CtxOperation_descriptor() {
    return Open_CtxOperation_descriptor();
  }
  template<typename T>
  static inline const std::string& CtxOperation_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CtxOperation>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CtxOperation_Name.");
    return Open_CtxOperation_Name(enum_t_value);
  }
  static inline bool CtxOperation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      CtxOperation* value) {
    return Open_CtxOperation_Parse(name, value);
  }

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

  enum : int {
    kCondFieldNumber = 2,
    kOpFieldNumber = 1,
  };
  // repeated .Mysqlx.Expect.Open.Condition cond = 2;
  int cond_size() const;
  private:
  int _internal_cond_size() const;
  public:
  void clear_cond();
  ::Mysqlx::Expect::Open_Condition* mutable_cond(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Expect::Open_Condition >*
      mutable_cond();
  private:
  const ::Mysqlx::Expect::Open_Condition& _internal_cond(int index) const;
  ::Mysqlx::Expect::Open_Condition* _internal_add_cond();
  public:
  const ::Mysqlx::Expect::Open_Condition& cond(int index) const;
  ::Mysqlx::Expect::Open_Condition* add_cond();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Expect::Open_Condition >&
      cond() const;

  // optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV];
  bool has_op() const;
  private:
  bool _internal_has_op() const;
  public:
  void clear_op();
  ::Mysqlx::Expect::Open_CtxOperation op() const;
  void set_op(::Mysqlx::Expect::Open_CtxOperation value);
  private:
  ::Mysqlx::Expect::Open_CtxOperation _internal_op() const;
  void _internal_set_op(::Mysqlx::Expect::Open_CtxOperation value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Expect.Open)
 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::Expect::Open_Condition > cond_;
    int op_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fexpect_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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


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

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

// required uint32 condition_key = 1;
inline bool Open_Condition::_internal_has_condition_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Open_Condition::has_condition_key() const {
  return _internal_has_condition_key();
}
inline void Open_Condition::clear_condition_key() {
  _impl_.condition_key_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t Open_Condition::_internal_condition_key() const {
  return _impl_.condition_key_;
}
inline uint32_t Open_Condition::condition_key() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Expect.Open.Condition.condition_key)
  return _internal_condition_key();
}
inline void Open_Condition::_internal_set_condition_key(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.condition_key_ = value;
}
inline void Open_Condition::set_condition_key(uint32_t value) {
  _internal_set_condition_key(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Expect.Open.Condition.condition_key)
}

// optional bytes condition_value = 2;
inline bool Open_Condition::_internal_has_condition_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Open_Condition::has_condition_value() const {
  return _internal_has_condition_value();
}
inline void Open_Condition::clear_condition_value() {
  _impl_.condition_value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Open_Condition::condition_value() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Expect.Open.Condition.condition_value)
  return _internal_condition_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Open_Condition::set_condition_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.condition_value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Expect.Open.Condition.condition_value)
}
inline std::string* Open_Condition::mutable_condition_value() {
  std::string* _s = _internal_mutable_condition_value();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Expect.Open.Condition.condition_value)
  return _s;
}
inline const std::string& Open_Condition::_internal_condition_value() const {
  return _impl_.condition_value_.Get();
}
inline void Open_Condition::_internal_set_condition_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.condition_value_.Set(value, GetArenaForAllocation());
}
inline std::string* Open_Condition::_internal_mutable_condition_value() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.condition_value_.Mutable(GetArenaForAllocation());
}
inline std::string* Open_Condition::release_condition_value() {
  // @@protoc_insertion_point(field_release:Mysqlx.Expect.Open.Condition.condition_value)
  if (!_internal_has_condition_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.condition_value_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.condition_value_.IsDefault()) {
    _impl_.condition_value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Open_Condition::set_allocated_condition_value(std::string* condition_value) {
  if (condition_value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.condition_value_.SetAllocated(condition_value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.condition_value_.IsDefault()) {
    _impl_.condition_value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expect.Open.Condition.condition_value)
}

// optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET];
inline bool Open_Condition::_internal_has_op() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Open_Condition::has_op() const {
  return _internal_has_op();
}
inline void Open_Condition::clear_op() {
  _impl_.op_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::Mysqlx::Expect::Open_Condition_ConditionOperation Open_Condition::_internal_op() const {
  return static_cast< ::Mysqlx::Expect::Open_Condition_ConditionOperation >(_impl_.op_);
}
inline ::Mysqlx::Expect::Open_Condition_ConditionOperation Open_Condition::op() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Expect.Open.Condition.op)
  return _internal_op();
}
inline void Open_Condition::_internal_set_op(::Mysqlx::Expect::Open_Condition_ConditionOperation value) {
  assert(::Mysqlx::Expect::Open_Condition_ConditionOperation_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.op_ = value;
}
inline void Open_Condition::set_op(::Mysqlx::Expect::Open_Condition_ConditionOperation value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Expect.Open.Condition.op)
}

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

// Open

// optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV];
inline bool Open::_internal_has_op() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Open::has_op() const {
  return _internal_has_op();
}
inline void Open::clear_op() {
  _impl_.op_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::Mysqlx::Expect::Open_CtxOperation Open::_internal_op() const {
  return static_cast< ::Mysqlx::Expect::Open_CtxOperation >(_impl_.op_);
}
inline ::Mysqlx::Expect::Open_CtxOperation Open::op() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Expect.Open.op)
  return _internal_op();
}
inline void Open::_internal_set_op(::Mysqlx::Expect::Open_CtxOperation value) {
  assert(::Mysqlx::Expect::Open_CtxOperation_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.op_ = value;
}
inline void Open::set_op(::Mysqlx::Expect::Open_CtxOperation value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Expect.Open.op)
}

// repeated .Mysqlx.Expect.Open.Condition cond = 2;
inline int Open::_internal_cond_size() const {
  return _impl_.cond_.size();
}
inline int Open::cond_size() const {
  return _internal_cond_size();
}
inline void Open::clear_cond() {
  _impl_.cond_.Clear();
}
inline ::Mysqlx::Expect::Open_Condition* Open::mutable_cond(int index) {
  // @@protoc_insertion_point(field_mutable:Mysqlx.Expect.Open.cond)
  return _impl_.cond_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Expect::Open_Condition >*
Open::mutable_cond() {
  // @@protoc_insertion_point(field_mutable_list:Mysqlx.Expect.Open.cond)
  return &_impl_.cond_;
}
inline const ::Mysqlx::Expect::Open_Condition& Open::_internal_cond(int index) const {
  return _impl_.cond_.Get(index);
}
inline const ::Mysqlx::Expect::Open_Condition& Open::cond(int index) const {
  // @@protoc_insertion_point(field_get:Mysqlx.Expect.Open.cond)
  return _internal_cond(index);
}
inline ::Mysqlx::Expect::Open_Condition* Open::_internal_add_cond() {
  return _impl_.cond_.Add();
}
inline ::Mysqlx::Expect::Open_Condition* Open::add_cond() {
  ::Mysqlx::Expect::Open_Condition* _add = _internal_add_cond();
  // @@protoc_insertion_point(field_add:Mysqlx.Expect.Open.cond)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Expect::Open_Condition >&
Open::cond() const {
  // @@protoc_insertion_point(field_list:Mysqlx.Expect.Open.cond)
  return _impl_.cond_;
}

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

// Close

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Expect
}  // namespace Mysqlx

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::Mysqlx::Expect::Open_Condition_Key> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Expect::Open_Condition_Key>() {
  return ::Mysqlx::Expect::Open_Condition_Key_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::Expect::Open_Condition_ConditionOperation> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Expect::Open_Condition_ConditionOperation>() {
  return ::Mysqlx::Expect::Open_Condition_ConditionOperation_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::Expect::Open_CtxOperation> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Expect::Open_CtxOperation>() {
  return ::Mysqlx::Expect::Open_CtxOperation_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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