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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mysqlx_5fdatatypes_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mysqlx_5fdatatypes_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_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mysqlx_5fdatatypes_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mysqlx_5fdatatypes_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mysqlx_5fdatatypes_2eproto;
namespace Mysqlx {
namespace Datatypes {
class Any;
struct AnyDefaultTypeInternal;
extern AnyDefaultTypeInternal _Any_default_instance_;
class Array;
struct ArrayDefaultTypeInternal;
extern ArrayDefaultTypeInternal _Array_default_instance_;
class Object;
struct ObjectDefaultTypeInternal;
extern ObjectDefaultTypeInternal _Object_default_instance_;
class Object_ObjectField;
struct Object_ObjectFieldDefaultTypeInternal;
extern Object_ObjectFieldDefaultTypeInternal _Object_ObjectField_default_instance_;
class Scalar;
struct ScalarDefaultTypeInternal;
extern ScalarDefaultTypeInternal _Scalar_default_instance_;
class Scalar_Octets;
struct Scalar_OctetsDefaultTypeInternal;
extern Scalar_OctetsDefaultTypeInternal _Scalar_Octets_default_instance_;
class Scalar_String;
struct Scalar_StringDefaultTypeInternal;
extern Scalar_StringDefaultTypeInternal _Scalar_String_default_instance_;
}  // namespace Datatypes
}  // namespace Mysqlx
PROTOBUF_NAMESPACE_OPEN
template<> ::Mysqlx::Datatypes::Any* Arena::CreateMaybeMessage<::Mysqlx::Datatypes::Any>(Arena*);
template<> ::Mysqlx::Datatypes::Array* Arena::CreateMaybeMessage<::Mysqlx::Datatypes::Array>(Arena*);
template<> ::Mysqlx::Datatypes::Object* Arena::CreateMaybeMessage<::Mysqlx::Datatypes::Object>(Arena*);
template<> ::Mysqlx::Datatypes::Object_ObjectField* Arena::CreateMaybeMessage<::Mysqlx::Datatypes::Object_ObjectField>(Arena*);
template<> ::Mysqlx::Datatypes::Scalar* Arena::CreateMaybeMessage<::Mysqlx::Datatypes::Scalar>(Arena*);
template<> ::Mysqlx::Datatypes::Scalar_Octets* Arena::CreateMaybeMessage<::Mysqlx::Datatypes::Scalar_Octets>(Arena*);
template<> ::Mysqlx::Datatypes::Scalar_String* Arena::CreateMaybeMessage<::Mysqlx::Datatypes::Scalar_String>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace Mysqlx {
namespace Datatypes {

enum Scalar_Type : int {
  Scalar_Type_V_SINT = 1,
  Scalar_Type_V_UINT = 2,
  Scalar_Type_V_NULL = 3,
  Scalar_Type_V_OCTETS = 4,
  Scalar_Type_V_DOUBLE = 5,
  Scalar_Type_V_FLOAT = 6,
  Scalar_Type_V_BOOL = 7,
  Scalar_Type_V_STRING = 8
};
bool Scalar_Type_IsValid(int value);
constexpr Scalar_Type Scalar_Type_Type_MIN = Scalar_Type_V_SINT;
constexpr Scalar_Type Scalar_Type_Type_MAX = Scalar_Type_V_STRING;
constexpr int Scalar_Type_Type_ARRAYSIZE = Scalar_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Scalar_Type_descriptor();
template<typename T>
inline const std::string& Scalar_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Scalar_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Scalar_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Scalar_Type_descriptor(), enum_t_value);
}
inline bool Scalar_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Scalar_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Scalar_Type>(
    Scalar_Type_descriptor(), name, value);
}
enum Any_Type : int {
  Any_Type_SCALAR = 1,
  Any_Type_OBJECT = 2,
  Any_Type_ARRAY = 3
};
bool Any_Type_IsValid(int value);
constexpr Any_Type Any_Type_Type_MIN = Any_Type_SCALAR;
constexpr Any_Type Any_Type_Type_MAX = Any_Type_ARRAY;
constexpr int Any_Type_Type_ARRAYSIZE = Any_Type_Type_MAX + 1;

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Datatypes.Scalar.String";
  }
  protected:
  explicit Scalar_String(::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 {
    kValueFieldNumber = 1,
    kCollationFieldNumber = 2,
  };
  // required bytes value = 1;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // optional uint64 collation = 2;
  bool has_collation() const;
  private:
  bool _internal_has_collation() const;
  public:
  void clear_collation();
  uint64_t collation() const;
  void set_collation(uint64_t value);
  private:
  uint64_t _internal_collation() const;
  void _internal_set_collation(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Scalar.String)
 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 value_;
    uint64_t collation_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fdatatypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Datatypes.Scalar.Octets";
  }
  protected:
  explicit Scalar_Octets(::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 {
    kValueFieldNumber = 1,
    kContentTypeFieldNumber = 2,
  };
  // required bytes value = 1;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // optional uint32 content_type = 2;
  bool has_content_type() const;
  private:
  bool _internal_has_content_type() const;
  public:
  void clear_content_type();
  uint32_t content_type() const;
  void set_content_type(uint32_t value);
  private:
  uint32_t _internal_content_type() const;
  void _internal_set_content_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Scalar.Octets)
 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 value_;
    uint32_t content_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fdatatypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Datatypes.Scalar";
  }
  protected:
  explicit Scalar(::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 Scalar_String String;
  typedef Scalar_Octets Octets;

  typedef Scalar_Type Type;
  static constexpr Type V_SINT =
    Scalar_Type_V_SINT;
  static constexpr Type V_UINT =
    Scalar_Type_V_UINT;
  static constexpr Type V_NULL =
    Scalar_Type_V_NULL;
  static constexpr Type V_OCTETS =
    Scalar_Type_V_OCTETS;
  static constexpr Type V_DOUBLE =
    Scalar_Type_V_DOUBLE;
  static constexpr Type V_FLOAT =
    Scalar_Type_V_FLOAT;
  static constexpr Type V_BOOL =
    Scalar_Type_V_BOOL;
  static constexpr Type V_STRING =
    Scalar_Type_V_STRING;
  static inline bool Type_IsValid(int value) {
    return Scalar_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Scalar_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Scalar_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Scalar_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Scalar_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 Scalar_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Scalar_Type_Parse(name, value);
  }

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

  enum : int {
    kVOctetsFieldNumber = 5,
    kVStringFieldNumber = 9,
    kVSignedIntFieldNumber = 2,
    kVUnsignedIntFieldNumber = 3,
    kVDoubleFieldNumber = 6,
    kVFloatFieldNumber = 7,
    kVBoolFieldNumber = 8,
    kTypeFieldNumber = 1,
  };
  // optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5;
  bool has_v_octets() const;
  private:
  bool _internal_has_v_octets() const;
  public:
  void clear_v_octets();
  const ::Mysqlx::Datatypes::Scalar_Octets& v_octets() const;
  PROTOBUF_NODISCARD ::Mysqlx::Datatypes::Scalar_Octets* release_v_octets();
  ::Mysqlx::Datatypes::Scalar_Octets* mutable_v_octets();
  void set_allocated_v_octets(::Mysqlx::Datatypes::Scalar_Octets* v_octets);
  private:
  const ::Mysqlx::Datatypes::Scalar_Octets& _internal_v_octets() const;
  ::Mysqlx::Datatypes::Scalar_Octets* _internal_mutable_v_octets();
  public:
  void unsafe_arena_set_allocated_v_octets(
      ::Mysqlx::Datatypes::Scalar_Octets* v_octets);
  ::Mysqlx::Datatypes::Scalar_Octets* unsafe_arena_release_v_octets();

  // optional .Mysqlx.Datatypes.Scalar.String v_string = 9;
  bool has_v_string() const;
  private:
  bool _internal_has_v_string() const;
  public:
  void clear_v_string();
  const ::Mysqlx::Datatypes::Scalar_String& v_string() const;
  PROTOBUF_NODISCARD ::Mysqlx::Datatypes::Scalar_String* release_v_string();
  ::Mysqlx::Datatypes::Scalar_String* mutable_v_string();
  void set_allocated_v_string(::Mysqlx::Datatypes::Scalar_String* v_string);
  private:
  const ::Mysqlx::Datatypes::Scalar_String& _internal_v_string() const;
  ::Mysqlx::Datatypes::Scalar_String* _internal_mutable_v_string();
  public:
  void unsafe_arena_set_allocated_v_string(
      ::Mysqlx::Datatypes::Scalar_String* v_string);
  ::Mysqlx::Datatypes::Scalar_String* unsafe_arena_release_v_string();

  // optional sint64 v_signed_int = 2;
  bool has_v_signed_int() const;
  private:
  bool _internal_has_v_signed_int() const;
  public:
  void clear_v_signed_int();
  int64_t v_signed_int() const;
  void set_v_signed_int(int64_t value);
  private:
  int64_t _internal_v_signed_int() const;
  void _internal_set_v_signed_int(int64_t value);
  public:

  // optional uint64 v_unsigned_int = 3;
  bool has_v_unsigned_int() const;
  private:
  bool _internal_has_v_unsigned_int() const;
  public:
  void clear_v_unsigned_int();
  uint64_t v_unsigned_int() const;
  void set_v_unsigned_int(uint64_t value);
  private:
  uint64_t _internal_v_unsigned_int() const;
  void _internal_set_v_unsigned_int(uint64_t value);
  public:

  // optional double v_double = 6;
  bool has_v_double() const;
  private:
  bool _internal_has_v_double() const;
  public:
  void clear_v_double();
  double v_double() const;
  void set_v_double(double value);
  private:
  double _internal_v_double() const;
  void _internal_set_v_double(double value);
  public:

  // optional float v_float = 7;
  bool has_v_float() const;
  private:
  bool _internal_has_v_float() const;
  public:
  void clear_v_float();
  float v_float() const;
  void set_v_float(float value);
  private:
  float _internal_v_float() const;
  void _internal_set_v_float(float value);
  public:

  // optional bool v_bool = 8;
  bool has_v_bool() const;
  private:
  bool _internal_has_v_bool() const;
  public:
  void clear_v_bool();
  bool v_bool() const;
  void set_v_bool(bool value);
  private:
  bool _internal_v_bool() const;
  void _internal_set_v_bool(bool value);
  public:

  // required .Mysqlx.Datatypes.Scalar.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::Mysqlx::Datatypes::Scalar_Type type() const;
  void set_type(::Mysqlx::Datatypes::Scalar_Type value);
  private:
  ::Mysqlx::Datatypes::Scalar_Type _internal_type() const;
  void _internal_set_type(::Mysqlx::Datatypes::Scalar_Type value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Scalar)
 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_;
    ::Mysqlx::Datatypes::Scalar_Octets* v_octets_;
    ::Mysqlx::Datatypes::Scalar_String* v_string_;
    int64_t v_signed_int_;
    uint64_t v_unsigned_int_;
    double v_double_;
    float v_float_;
    bool v_bool_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fdatatypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Datatypes.Object.ObjectField";
  }
  protected:
  explicit Object_ObjectField(::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 {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // required string key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

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

  // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Object.ObjectField)
 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 key_;
    ::Mysqlx::Datatypes::Any* value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fdatatypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Datatypes.Object";
  }
  protected:
  explicit Object(::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 Object_ObjectField ObjectField;

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

  enum : int {
    kFldFieldNumber = 1,
  };
  // repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1;
  int fld_size() const;
  private:
  int _internal_fld_size() const;
  public:
  void clear_fld();
  ::Mysqlx::Datatypes::Object_ObjectField* mutable_fld(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Object_ObjectField >*
      mutable_fld();
  private:
  const ::Mysqlx::Datatypes::Object_ObjectField& _internal_fld(int index) const;
  ::Mysqlx::Datatypes::Object_ObjectField* _internal_add_fld();
  public:
  const ::Mysqlx::Datatypes::Object_ObjectField& fld(int index) const;
  ::Mysqlx::Datatypes::Object_ObjectField* add_fld();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Object_ObjectField >&
      fld() const;

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Object_ObjectField > fld_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fdatatypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Datatypes.Array";
  }
  protected:
  explicit Array(::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 {
    kValueFieldNumber = 1,
  };
  // repeated .Mysqlx.Datatypes.Any value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  ::Mysqlx::Datatypes::Any* mutable_value(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Any >*
      mutable_value();
  private:
  const ::Mysqlx::Datatypes::Any& _internal_value(int index) const;
  ::Mysqlx::Datatypes::Any* _internal_add_value();
  public:
  const ::Mysqlx::Datatypes::Any& value(int index) const;
  ::Mysqlx::Datatypes::Any* add_value();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Any >&
      value() const;

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Any > value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fdatatypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Mysqlx.Datatypes.Any";
  }
  protected:
  explicit Any(::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 Any_Type Type;
  static constexpr Type SCALAR =
    Any_Type_SCALAR;
  static constexpr Type OBJECT =
    Any_Type_OBJECT;
  static constexpr Type ARRAY =
    Any_Type_ARRAY;
  static inline bool Type_IsValid(int value) {
    return Any_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Any_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Any_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Any_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Any_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 Any_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Any_Type_Parse(name, value);
  }

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

  enum : int {
    kScalarFieldNumber = 2,
    kObjFieldNumber = 3,
    kArrayFieldNumber = 4,
    kTypeFieldNumber = 1,
  };
  // optional .Mysqlx.Datatypes.Scalar scalar = 2;
  bool has_scalar() const;
  private:
  bool _internal_has_scalar() const;
  public:
  void clear_scalar();
  const ::Mysqlx::Datatypes::Scalar& scalar() const;
  PROTOBUF_NODISCARD ::Mysqlx::Datatypes::Scalar* release_scalar();
  ::Mysqlx::Datatypes::Scalar* mutable_scalar();
  void set_allocated_scalar(::Mysqlx::Datatypes::Scalar* scalar);
  private:
  const ::Mysqlx::Datatypes::Scalar& _internal_scalar() const;
  ::Mysqlx::Datatypes::Scalar* _internal_mutable_scalar();
  public:
  void unsafe_arena_set_allocated_scalar(
      ::Mysqlx::Datatypes::Scalar* scalar);
  ::Mysqlx::Datatypes::Scalar* unsafe_arena_release_scalar();

  // optional .Mysqlx.Datatypes.Object obj = 3;
  bool has_obj() const;
  private:
  bool _internal_has_obj() const;
  public:
  void clear_obj();
  const ::Mysqlx::Datatypes::Object& obj() const;
  PROTOBUF_NODISCARD ::Mysqlx::Datatypes::Object* release_obj();
  ::Mysqlx::Datatypes::Object* mutable_obj();
  void set_allocated_obj(::Mysqlx::Datatypes::Object* obj);
  private:
  const ::Mysqlx::Datatypes::Object& _internal_obj() const;
  ::Mysqlx::Datatypes::Object* _internal_mutable_obj();
  public:
  void unsafe_arena_set_allocated_obj(
      ::Mysqlx::Datatypes::Object* obj);
  ::Mysqlx::Datatypes::Object* unsafe_arena_release_obj();

  // optional .Mysqlx.Datatypes.Array array = 4;
  bool has_array() const;
  private:
  bool _internal_has_array() const;
  public:
  void clear_array();
  const ::Mysqlx::Datatypes::Array& array() const;
  PROTOBUF_NODISCARD ::Mysqlx::Datatypes::Array* release_array();
  ::Mysqlx::Datatypes::Array* mutable_array();
  void set_allocated_array(::Mysqlx::Datatypes::Array* array);
  private:
  const ::Mysqlx::Datatypes::Array& _internal_array() const;
  ::Mysqlx::Datatypes::Array* _internal_mutable_array();
  public:
  void unsafe_arena_set_allocated_array(
      ::Mysqlx::Datatypes::Array* array);
  ::Mysqlx::Datatypes::Array* unsafe_arena_release_array();

  // required .Mysqlx.Datatypes.Any.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::Mysqlx::Datatypes::Any_Type type() const;
  void set_type(::Mysqlx::Datatypes::Any_Type value);
  private:
  ::Mysqlx::Datatypes::Any_Type _internal_type() const;
  void _internal_set_type(::Mysqlx::Datatypes::Any_Type value);
  public:

  // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Any)
 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_;
    ::Mysqlx::Datatypes::Scalar* scalar_;
    ::Mysqlx::Datatypes::Object* obj_;
    ::Mysqlx::Datatypes::Array* array_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mysqlx_5fdatatypes_2eproto;
};
// ===================================================================


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

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

// required bytes value = 1;
inline bool Scalar_String::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Scalar_String::has_value() const {
  return _internal_has_value();
}
inline void Scalar_String::clear_value() {
  _impl_.value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Scalar_String::value() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.String.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Scalar_String::set_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.String.value)
}
inline std::string* Scalar_String::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Scalar.String.value)
  return _s;
}
inline const std::string& Scalar_String::_internal_value() const {
  return _impl_.value_.Get();
}
inline void Scalar_String::_internal_set_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* Scalar_String::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* Scalar_String::release_value() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Scalar.String.value)
  if (!_internal_has_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.value_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Scalar_String::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Datatypes.Scalar.String.value)
}

// optional uint64 collation = 2;
inline bool Scalar_String::_internal_has_collation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Scalar_String::has_collation() const {
  return _internal_has_collation();
}
inline void Scalar_String::clear_collation() {
  _impl_.collation_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t Scalar_String::_internal_collation() const {
  return _impl_.collation_;
}
inline uint64_t Scalar_String::collation() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.String.collation)
  return _internal_collation();
}
inline void Scalar_String::_internal_set_collation(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.collation_ = value;
}
inline void Scalar_String::set_collation(uint64_t value) {
  _internal_set_collation(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.String.collation)
}

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

// Scalar_Octets

// required bytes value = 1;
inline bool Scalar_Octets::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Scalar_Octets::has_value() const {
  return _internal_has_value();
}
inline void Scalar_Octets::clear_value() {
  _impl_.value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Scalar_Octets::value() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.Octets.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Scalar_Octets::set_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.Octets.value)
}
inline std::string* Scalar_Octets::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Scalar.Octets.value)
  return _s;
}
inline const std::string& Scalar_Octets::_internal_value() const {
  return _impl_.value_.Get();
}
inline void Scalar_Octets::_internal_set_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* Scalar_Octets::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* Scalar_Octets::release_value() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Scalar.Octets.value)
  if (!_internal_has_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.value_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Scalar_Octets::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Datatypes.Scalar.Octets.value)
}

// optional uint32 content_type = 2;
inline bool Scalar_Octets::_internal_has_content_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Scalar_Octets::has_content_type() const {
  return _internal_has_content_type();
}
inline void Scalar_Octets::clear_content_type() {
  _impl_.content_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t Scalar_Octets::_internal_content_type() const {
  return _impl_.content_type_;
}
inline uint32_t Scalar_Octets::content_type() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.Octets.content_type)
  return _internal_content_type();
}
inline void Scalar_Octets::_internal_set_content_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.content_type_ = value;
}
inline void Scalar_Octets::set_content_type(uint32_t value) {
  _internal_set_content_type(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.Octets.content_type)
}

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

// Scalar

// required .Mysqlx.Datatypes.Scalar.Type type = 1;
inline bool Scalar::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Scalar::has_type() const {
  return _internal_has_type();
}
inline void Scalar::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::Mysqlx::Datatypes::Scalar_Type Scalar::_internal_type() const {
  return static_cast< ::Mysqlx::Datatypes::Scalar_Type >(_impl_.type_);
}
inline ::Mysqlx::Datatypes::Scalar_Type Scalar::type() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.type)
  return _internal_type();
}
inline void Scalar::_internal_set_type(::Mysqlx::Datatypes::Scalar_Type value) {
  assert(::Mysqlx::Datatypes::Scalar_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.type_ = value;
}
inline void Scalar::set_type(::Mysqlx::Datatypes::Scalar_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.type)
}

// optional sint64 v_signed_int = 2;
inline bool Scalar::_internal_has_v_signed_int() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Scalar::has_v_signed_int() const {
  return _internal_has_v_signed_int();
}
inline void Scalar::clear_v_signed_int() {
  _impl_.v_signed_int_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t Scalar::_internal_v_signed_int() const {
  return _impl_.v_signed_int_;
}
inline int64_t Scalar::v_signed_int() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.v_signed_int)
  return _internal_v_signed_int();
}
inline void Scalar::_internal_set_v_signed_int(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.v_signed_int_ = value;
}
inline void Scalar::set_v_signed_int(int64_t value) {
  _internal_set_v_signed_int(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.v_signed_int)
}

// optional uint64 v_unsigned_int = 3;
inline bool Scalar::_internal_has_v_unsigned_int() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Scalar::has_v_unsigned_int() const {
  return _internal_has_v_unsigned_int();
}
inline void Scalar::clear_v_unsigned_int() {
  _impl_.v_unsigned_int_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t Scalar::_internal_v_unsigned_int() const {
  return _impl_.v_unsigned_int_;
}
inline uint64_t Scalar::v_unsigned_int() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.v_unsigned_int)
  return _internal_v_unsigned_int();
}
inline void Scalar::_internal_set_v_unsigned_int(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.v_unsigned_int_ = value;
}
inline void Scalar::set_v_unsigned_int(uint64_t value) {
  _internal_set_v_unsigned_int(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.v_unsigned_int)
}

// optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5;
inline bool Scalar::_internal_has_v_octets() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.v_octets_ != nullptr);
  return value;
}
inline bool Scalar::has_v_octets() const {
  return _internal_has_v_octets();
}
inline void Scalar::clear_v_octets() {
  if (_impl_.v_octets_ != nullptr) _impl_.v_octets_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::Mysqlx::Datatypes::Scalar_Octets& Scalar::_internal_v_octets() const {
  const ::Mysqlx::Datatypes::Scalar_Octets* p = _impl_.v_octets_;
  return p != nullptr ? *p : reinterpret_cast<const ::Mysqlx::Datatypes::Scalar_Octets&>(
      ::Mysqlx::Datatypes::_Scalar_Octets_default_instance_);
}
inline const ::Mysqlx::Datatypes::Scalar_Octets& Scalar::v_octets() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.v_octets)
  return _internal_v_octets();
}
inline void Scalar::unsafe_arena_set_allocated_v_octets(
    ::Mysqlx::Datatypes::Scalar_Octets* v_octets) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.v_octets_);
  }
  _impl_.v_octets_ = v_octets;
  if (v_octets) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Mysqlx.Datatypes.Scalar.v_octets)
}
inline ::Mysqlx::Datatypes::Scalar_Octets* Scalar::release_v_octets() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::Mysqlx::Datatypes::Scalar_Octets* temp = _impl_.v_octets_;
  _impl_.v_octets_ = 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_Octets* Scalar::unsafe_arena_release_v_octets() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Scalar.v_octets)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::Mysqlx::Datatypes::Scalar_Octets* temp = _impl_.v_octets_;
  _impl_.v_octets_ = nullptr;
  return temp;
}
inline ::Mysqlx::Datatypes::Scalar_Octets* Scalar::_internal_mutable_v_octets() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.v_octets_ == nullptr) {
    auto* p = CreateMaybeMessage<::Mysqlx::Datatypes::Scalar_Octets>(GetArenaForAllocation());
    _impl_.v_octets_ = p;
  }
  return _impl_.v_octets_;
}
inline ::Mysqlx::Datatypes::Scalar_Octets* Scalar::mutable_v_octets() {
  ::Mysqlx::Datatypes::Scalar_Octets* _msg = _internal_mutable_v_octets();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Scalar.v_octets)
  return _msg;
}
inline void Scalar::set_allocated_v_octets(::Mysqlx::Datatypes::Scalar_Octets* v_octets) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.v_octets_;
  }
  if (v_octets) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(v_octets);
    if (message_arena != submessage_arena) {
      v_octets = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, v_octets, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.v_octets_ = v_octets;
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Datatypes.Scalar.v_octets)
}

// optional double v_double = 6;
inline bool Scalar::_internal_has_v_double() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Scalar::has_v_double() const {
  return _internal_has_v_double();
}
inline void Scalar::clear_v_double() {
  _impl_.v_double_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline double Scalar::_internal_v_double() const {
  return _impl_.v_double_;
}
inline double Scalar::v_double() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.v_double)
  return _internal_v_double();
}
inline void Scalar::_internal_set_v_double(double value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.v_double_ = value;
}
inline void Scalar::set_v_double(double value) {
  _internal_set_v_double(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.v_double)
}

// optional float v_float = 7;
inline bool Scalar::_internal_has_v_float() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Scalar::has_v_float() const {
  return _internal_has_v_float();
}
inline void Scalar::clear_v_float() {
  _impl_.v_float_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float Scalar::_internal_v_float() const {
  return _impl_.v_float_;
}
inline float Scalar::v_float() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.v_float)
  return _internal_v_float();
}
inline void Scalar::_internal_set_v_float(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.v_float_ = value;
}
inline void Scalar::set_v_float(float value) {
  _internal_set_v_float(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.v_float)
}

// optional bool v_bool = 8;
inline bool Scalar::_internal_has_v_bool() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Scalar::has_v_bool() const {
  return _internal_has_v_bool();
}
inline void Scalar::clear_v_bool() {
  _impl_.v_bool_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool Scalar::_internal_v_bool() const {
  return _impl_.v_bool_;
}
inline bool Scalar::v_bool() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.v_bool)
  return _internal_v_bool();
}
inline void Scalar::_internal_set_v_bool(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.v_bool_ = value;
}
inline void Scalar::set_v_bool(bool value) {
  _internal_set_v_bool(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Scalar.v_bool)
}

// optional .Mysqlx.Datatypes.Scalar.String v_string = 9;
inline bool Scalar::_internal_has_v_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.v_string_ != nullptr);
  return value;
}
inline bool Scalar::has_v_string() const {
  return _internal_has_v_string();
}
inline void Scalar::clear_v_string() {
  if (_impl_.v_string_ != nullptr) _impl_.v_string_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::Mysqlx::Datatypes::Scalar_String& Scalar::_internal_v_string() const {
  const ::Mysqlx::Datatypes::Scalar_String* p = _impl_.v_string_;
  return p != nullptr ? *p : reinterpret_cast<const ::Mysqlx::Datatypes::Scalar_String&>(
      ::Mysqlx::Datatypes::_Scalar_String_default_instance_);
}
inline const ::Mysqlx::Datatypes::Scalar_String& Scalar::v_string() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Scalar.v_string)
  return _internal_v_string();
}
inline void Scalar::unsafe_arena_set_allocated_v_string(
    ::Mysqlx::Datatypes::Scalar_String* v_string) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.v_string_);
  }
  _impl_.v_string_ = v_string;
  if (v_string) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Mysqlx.Datatypes.Scalar.v_string)
}
inline ::Mysqlx::Datatypes::Scalar_String* Scalar::release_v_string() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Mysqlx::Datatypes::Scalar_String* temp = _impl_.v_string_;
  _impl_.v_string_ = 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_String* Scalar::unsafe_arena_release_v_string() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Scalar.v_string)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Mysqlx::Datatypes::Scalar_String* temp = _impl_.v_string_;
  _impl_.v_string_ = nullptr;
  return temp;
}
inline ::Mysqlx::Datatypes::Scalar_String* Scalar::_internal_mutable_v_string() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.v_string_ == nullptr) {
    auto* p = CreateMaybeMessage<::Mysqlx::Datatypes::Scalar_String>(GetArenaForAllocation());
    _impl_.v_string_ = p;
  }
  return _impl_.v_string_;
}
inline ::Mysqlx::Datatypes::Scalar_String* Scalar::mutable_v_string() {
  ::Mysqlx::Datatypes::Scalar_String* _msg = _internal_mutable_v_string();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Scalar.v_string)
  return _msg;
}
inline void Scalar::set_allocated_v_string(::Mysqlx::Datatypes::Scalar_String* v_string) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.v_string_;
  }
  if (v_string) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(v_string);
    if (message_arena != submessage_arena) {
      v_string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, v_string, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.v_string_ = v_string;
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Datatypes.Scalar.v_string)
}

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

// Object_ObjectField

// required string key = 1;
inline bool Object_ObjectField::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Object_ObjectField::has_key() const {
  return _internal_has_key();
}
inline void Object_ObjectField::clear_key() {
  _impl_.key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Object_ObjectField::key() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Object.ObjectField.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Object_ObjectField::set_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Object.ObjectField.key)
}
inline std::string* Object_ObjectField::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Object.ObjectField.key)
  return _s;
}
inline const std::string& Object_ObjectField::_internal_key() const {
  return _impl_.key_.Get();
}
inline void Object_ObjectField::_internal_set_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* Object_ObjectField::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* Object_ObjectField::release_key() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Object.ObjectField.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.key_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Object_ObjectField::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Datatypes.Object.ObjectField.key)
}

// required .Mysqlx.Datatypes.Any value = 2;
inline bool Object_ObjectField::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline bool Object_ObjectField::has_value() const {
  return _internal_has_value();
}
inline void Object_ObjectField::clear_value() {
  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::Mysqlx::Datatypes::Any& Object_ObjectField::_internal_value() const {
  const ::Mysqlx::Datatypes::Any* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::Mysqlx::Datatypes::Any&>(
      ::Mysqlx::Datatypes::_Any_default_instance_);
}
inline const ::Mysqlx::Datatypes::Any& Object_ObjectField::value() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Object.ObjectField.value)
  return _internal_value();
}
inline void Object_ObjectField::unsafe_arena_set_allocated_value(
    ::Mysqlx::Datatypes::Any* 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.Datatypes.Object.ObjectField.value)
}
inline ::Mysqlx::Datatypes::Any* Object_ObjectField::release_value() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Mysqlx::Datatypes::Any* 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::Any* Object_ObjectField::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Object.ObjectField.value)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Mysqlx::Datatypes::Any* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::Mysqlx::Datatypes::Any* Object_ObjectField::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::Mysqlx::Datatypes::Any>(GetArenaForAllocation());
    _impl_.value_ = p;
  }
  return _impl_.value_;
}
inline ::Mysqlx::Datatypes::Any* Object_ObjectField::mutable_value() {
  ::Mysqlx::Datatypes::Any* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Object.ObjectField.value)
  return _msg;
}
inline void Object_ObjectField::set_allocated_value(::Mysqlx::Datatypes::Any* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(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.Datatypes.Object.ObjectField.value)
}

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

// Object

// repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1;
inline int Object::_internal_fld_size() const {
  return _impl_.fld_.size();
}
inline int Object::fld_size() const {
  return _internal_fld_size();
}
inline void Object::clear_fld() {
  _impl_.fld_.Clear();
}
inline ::Mysqlx::Datatypes::Object_ObjectField* Object::mutable_fld(int index) {
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Object.fld)
  return _impl_.fld_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Object_ObjectField >*
Object::mutable_fld() {
  // @@protoc_insertion_point(field_mutable_list:Mysqlx.Datatypes.Object.fld)
  return &_impl_.fld_;
}
inline const ::Mysqlx::Datatypes::Object_ObjectField& Object::_internal_fld(int index) const {
  return _impl_.fld_.Get(index);
}
inline const ::Mysqlx::Datatypes::Object_ObjectField& Object::fld(int index) const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Object.fld)
  return _internal_fld(index);
}
inline ::Mysqlx::Datatypes::Object_ObjectField* Object::_internal_add_fld() {
  return _impl_.fld_.Add();
}
inline ::Mysqlx::Datatypes::Object_ObjectField* Object::add_fld() {
  ::Mysqlx::Datatypes::Object_ObjectField* _add = _internal_add_fld();
  // @@protoc_insertion_point(field_add:Mysqlx.Datatypes.Object.fld)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Mysqlx::Datatypes::Object_ObjectField >&
Object::fld() const {
  // @@protoc_insertion_point(field_list:Mysqlx.Datatypes.Object.fld)
  return _impl_.fld_;
}

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

// Array

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

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

// Any

// required .Mysqlx.Datatypes.Any.Type type = 1;
inline bool Any::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Any::has_type() const {
  return _internal_has_type();
}
inline void Any::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::Mysqlx::Datatypes::Any_Type Any::_internal_type() const {
  return static_cast< ::Mysqlx::Datatypes::Any_Type >(_impl_.type_);
}
inline ::Mysqlx::Datatypes::Any_Type Any::type() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Any.type)
  return _internal_type();
}
inline void Any::_internal_set_type(::Mysqlx::Datatypes::Any_Type value) {
  assert(::Mysqlx::Datatypes::Any_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.type_ = value;
}
inline void Any::set_type(::Mysqlx::Datatypes::Any_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:Mysqlx.Datatypes.Any.type)
}

// optional .Mysqlx.Datatypes.Scalar scalar = 2;
inline bool Any::_internal_has_scalar() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.scalar_ != nullptr);
  return value;
}
inline bool Any::has_scalar() const {
  return _internal_has_scalar();
}
inline void Any::clear_scalar() {
  if (_impl_.scalar_ != nullptr) _impl_.scalar_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::Mysqlx::Datatypes::Scalar& Any::_internal_scalar() const {
  const ::Mysqlx::Datatypes::Scalar* p = _impl_.scalar_;
  return p != nullptr ? *p : reinterpret_cast<const ::Mysqlx::Datatypes::Scalar&>(
      ::Mysqlx::Datatypes::_Scalar_default_instance_);
}
inline const ::Mysqlx::Datatypes::Scalar& Any::scalar() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Any.scalar)
  return _internal_scalar();
}
inline void Any::unsafe_arena_set_allocated_scalar(
    ::Mysqlx::Datatypes::Scalar* scalar) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.scalar_);
  }
  _impl_.scalar_ = scalar;
  if (scalar) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Mysqlx.Datatypes.Any.scalar)
}
inline ::Mysqlx::Datatypes::Scalar* Any::release_scalar() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::Mysqlx::Datatypes::Scalar* temp = _impl_.scalar_;
  _impl_.scalar_ = 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* Any::unsafe_arena_release_scalar() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Any.scalar)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::Mysqlx::Datatypes::Scalar* temp = _impl_.scalar_;
  _impl_.scalar_ = nullptr;
  return temp;
}
inline ::Mysqlx::Datatypes::Scalar* Any::_internal_mutable_scalar() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.scalar_ == nullptr) {
    auto* p = CreateMaybeMessage<::Mysqlx::Datatypes::Scalar>(GetArenaForAllocation());
    _impl_.scalar_ = p;
  }
  return _impl_.scalar_;
}
inline ::Mysqlx::Datatypes::Scalar* Any::mutable_scalar() {
  ::Mysqlx::Datatypes::Scalar* _msg = _internal_mutable_scalar();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Any.scalar)
  return _msg;
}
inline void Any::set_allocated_scalar(::Mysqlx::Datatypes::Scalar* scalar) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.scalar_;
  }
  if (scalar) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(scalar);
    if (message_arena != submessage_arena) {
      scalar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scalar, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.scalar_ = scalar;
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Datatypes.Any.scalar)
}

// optional .Mysqlx.Datatypes.Object obj = 3;
inline bool Any::_internal_has_obj() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.obj_ != nullptr);
  return value;
}
inline bool Any::has_obj() const {
  return _internal_has_obj();
}
inline void Any::clear_obj() {
  if (_impl_.obj_ != nullptr) _impl_.obj_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::Mysqlx::Datatypes::Object& Any::_internal_obj() const {
  const ::Mysqlx::Datatypes::Object* p = _impl_.obj_;
  return p != nullptr ? *p : reinterpret_cast<const ::Mysqlx::Datatypes::Object&>(
      ::Mysqlx::Datatypes::_Object_default_instance_);
}
inline const ::Mysqlx::Datatypes::Object& Any::obj() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Any.obj)
  return _internal_obj();
}
inline void Any::unsafe_arena_set_allocated_obj(
    ::Mysqlx::Datatypes::Object* obj) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.obj_);
  }
  _impl_.obj_ = obj;
  if (obj) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Mysqlx.Datatypes.Any.obj)
}
inline ::Mysqlx::Datatypes::Object* Any::release_obj() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Mysqlx::Datatypes::Object* temp = _impl_.obj_;
  _impl_.obj_ = 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::Object* Any::unsafe_arena_release_obj() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Any.obj)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Mysqlx::Datatypes::Object* temp = _impl_.obj_;
  _impl_.obj_ = nullptr;
  return temp;
}
inline ::Mysqlx::Datatypes::Object* Any::_internal_mutable_obj() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.obj_ == nullptr) {
    auto* p = CreateMaybeMessage<::Mysqlx::Datatypes::Object>(GetArenaForAllocation());
    _impl_.obj_ = p;
  }
  return _impl_.obj_;
}
inline ::Mysqlx::Datatypes::Object* Any::mutable_obj() {
  ::Mysqlx::Datatypes::Object* _msg = _internal_mutable_obj();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Any.obj)
  return _msg;
}
inline void Any::set_allocated_obj(::Mysqlx::Datatypes::Object* obj) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.obj_;
  }
  if (obj) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(obj);
    if (message_arena != submessage_arena) {
      obj = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, obj, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.obj_ = obj;
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Datatypes.Any.obj)
}

// optional .Mysqlx.Datatypes.Array array = 4;
inline bool Any::_internal_has_array() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.array_ != nullptr);
  return value;
}
inline bool Any::has_array() const {
  return _internal_has_array();
}
inline void Any::clear_array() {
  if (_impl_.array_ != nullptr) _impl_.array_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::Mysqlx::Datatypes::Array& Any::_internal_array() const {
  const ::Mysqlx::Datatypes::Array* p = _impl_.array_;
  return p != nullptr ? *p : reinterpret_cast<const ::Mysqlx::Datatypes::Array&>(
      ::Mysqlx::Datatypes::_Array_default_instance_);
}
inline const ::Mysqlx::Datatypes::Array& Any::array() const {
  // @@protoc_insertion_point(field_get:Mysqlx.Datatypes.Any.array)
  return _internal_array();
}
inline void Any::unsafe_arena_set_allocated_array(
    ::Mysqlx::Datatypes::Array* array) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.array_);
  }
  _impl_.array_ = array;
  if (array) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Mysqlx.Datatypes.Any.array)
}
inline ::Mysqlx::Datatypes::Array* Any::release_array() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::Mysqlx::Datatypes::Array* temp = _impl_.array_;
  _impl_.array_ = 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::Array* Any::unsafe_arena_release_array() {
  // @@protoc_insertion_point(field_release:Mysqlx.Datatypes.Any.array)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::Mysqlx::Datatypes::Array* temp = _impl_.array_;
  _impl_.array_ = nullptr;
  return temp;
}
inline ::Mysqlx::Datatypes::Array* Any::_internal_mutable_array() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.array_ == nullptr) {
    auto* p = CreateMaybeMessage<::Mysqlx::Datatypes::Array>(GetArenaForAllocation());
    _impl_.array_ = p;
  }
  return _impl_.array_;
}
inline ::Mysqlx::Datatypes::Array* Any::mutable_array() {
  ::Mysqlx::Datatypes::Array* _msg = _internal_mutable_array();
  // @@protoc_insertion_point(field_mutable:Mysqlx.Datatypes.Any.array)
  return _msg;
}
inline void Any::set_allocated_array(::Mysqlx::Datatypes::Array* array) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.array_;
  }
  if (array) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(array);
    if (message_arena != submessage_arena) {
      array = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, array, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.array_ = array;
  // @@protoc_insertion_point(field_set_allocated:Mysqlx.Datatypes.Any.array)
}

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Datatypes
}  // namespace Mysqlx

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::Mysqlx::Datatypes::Scalar_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Datatypes::Scalar_Type>() {
  return ::Mysqlx::Datatypes::Scalar_Type_descriptor();
}
template <> struct is_proto_enum< ::Mysqlx::Datatypes::Any_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Mysqlx::Datatypes::Any_Type>() {
  return ::Mysqlx::Datatypes::Any_Type_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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