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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mqtt_5fasync_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mqtt_5fasync_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 4000000
#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 4000000 < 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_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.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/unknown_field_set.h>
#include <google/protobuf/wrappers.pb.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mqtt_5fasync_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mqtt_5fasync_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mqtt_5fasync_2eproto;
class ConnectOps;
class ConnectOpsDefaultTypeInternal;
extern ConnectOpsDefaultTypeInternal _ConnectOps_default_instance_;
class CreateOpts;
class CreateOptsDefaultTypeInternal;
extern CreateOptsDefaultTypeInternal _CreateOpts_default_instance_;
class MqttAsyncConfig;
class MqttAsyncConfigDefaultTypeInternal;
extern MqttAsyncConfigDefaultTypeInternal _MqttAsyncConfig_default_instance_;
class SendMessageEtc;
class SendMessageEtcDefaultTypeInternal;
extern SendMessageEtcDefaultTypeInternal _SendMessageEtc_default_instance_;
class SubscribeEtc;
class SubscribeEtcDefaultTypeInternal;
extern SubscribeEtcDefaultTypeInternal _SubscribeEtc_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::ConnectOps* Arena::CreateMaybeMessage<::ConnectOps>(Arena*);
template<> ::CreateOpts* Arena::CreateMaybeMessage<::CreateOpts>(Arena*);
template<> ::MqttAsyncConfig* Arena::CreateMaybeMessage<::MqttAsyncConfig>(Arena*);
template<> ::SendMessageEtc* Arena::CreateMaybeMessage<::SendMessageEtc>(Arena*);
template<> ::SubscribeEtc* Arena::CreateMaybeMessage<::SubscribeEtc>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

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

class CreateOpts PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CreateOpts) */ {
 public:
  inline CreateOpts() : CreateOpts(nullptr) {}
  virtual ~CreateOpts();

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

  inline CreateOpts& operator=(const CreateOpts& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateOpts& operator=(CreateOpts&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateOpts& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CreateOpts* internal_default_instance() {
    return reinterpret_cast<const CreateOpts*>(
               &_CreateOpts_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CreateOpts& a, CreateOpts& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateOpts* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateOpts* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateOpts* New() const final {
    return CreateMaybeMessage<CreateOpts>(nullptr);
  }

  CreateOpts* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateOpts>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateOpts& from);
  void MergeFrom(const CreateOpts& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateOpts* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CreateOpts";
  }
  protected:
  explicit CreateOpts(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_mqtt_5fasync_2eproto);
    return ::descriptor_table_mqtt_5fasync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMaxBufferedMessagesFieldNumber = 3,
  };
  // optional int32 maxBufferedMessages = 3 [default = 10000];
  bool has_maxbufferedmessages() const;
  private:
  bool _internal_has_maxbufferedmessages() const;
  public:
  void clear_maxbufferedmessages();
  ::PROTOBUF_NAMESPACE_ID::int32 maxbufferedmessages() const;
  void set_maxbufferedmessages(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_maxbufferedmessages() const;
  void _internal_set_maxbufferedmessages(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 maxbufferedmessages_;
  friend struct ::TableStruct_mqtt_5fasync_2eproto;
};
// -------------------------------------------------------------------

class ConnectOps PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ConnectOps) */ {
 public:
  inline ConnectOps() : ConnectOps(nullptr) {}
  virtual ~ConnectOps();

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

  inline ConnectOps& operator=(const ConnectOps& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConnectOps& operator=(ConnectOps&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ConnectOps& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConnectOps* internal_default_instance() {
    return reinterpret_cast<const ConnectOps*>(
               &_ConnectOps_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(ConnectOps& a, ConnectOps& b) {
    a.Swap(&b);
  }
  inline void Swap(ConnectOps* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConnectOps* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ConnectOps* New() const final {
    return CreateMaybeMessage<ConnectOps>(nullptr);
  }

  ConnectOps* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConnectOps>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ConnectOps& from);
  void MergeFrom(const ConnectOps& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConnectOps* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ConnectOps";
  }
  protected:
  explicit ConnectOps(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_mqtt_5fasync_2eproto);
    return ::descriptor_table_mqtt_5fasync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kKeepAliveIntervalFieldNumber = 2,
    kCleansessionFieldNumber = 1,
    kAutomaticReconnectFieldNumber = 3,
    kMinRetryIntervalFieldNumber = 4,
    kMaxRetryIntervalFieldNumber = 5,
  };
  // optional int32 keepAliveInterval = 2 [default = 30];
  bool has_keepaliveinterval() const;
  private:
  bool _internal_has_keepaliveinterval() const;
  public:
  void clear_keepaliveinterval();
  ::PROTOBUF_NAMESPACE_ID::int32 keepaliveinterval() const;
  void set_keepaliveinterval(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_keepaliveinterval() const;
  void _internal_set_keepaliveinterval(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional bool cleansession = 1 [default = true];
  bool has_cleansession() const;
  private:
  bool _internal_has_cleansession() const;
  public:
  void clear_cleansession();
  bool cleansession() const;
  void set_cleansession(bool value);
  private:
  bool _internal_cleansession() const;
  void _internal_set_cleansession(bool value);
  public:

  // optional bool automaticReconnect = 3 [default = true];
  bool has_automaticreconnect() const;
  private:
  bool _internal_has_automaticreconnect() const;
  public:
  void clear_automaticreconnect();
  bool automaticreconnect() const;
  void set_automaticreconnect(bool value);
  private:
  bool _internal_automaticreconnect() const;
  void _internal_set_automaticreconnect(bool value);
  public:

  // optional int32 minRetryInterval = 4 [default = 3];
  bool has_minretryinterval() const;
  private:
  bool _internal_has_minretryinterval() const;
  public:
  void clear_minretryinterval();
  ::PROTOBUF_NAMESPACE_ID::int32 minretryinterval() const;
  void set_minretryinterval(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_minretryinterval() const;
  void _internal_set_minretryinterval(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 maxRetryInterval = 5 [default = 10];
  bool has_maxretryinterval() const;
  private:
  bool _internal_has_maxretryinterval() const;
  public:
  void clear_maxretryinterval();
  ::PROTOBUF_NAMESPACE_ID::int32 maxretryinterval() const;
  void set_maxretryinterval(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_maxretryinterval() const;
  void _internal_set_maxretryinterval(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 keepaliveinterval_;
  bool cleansession_;
  bool automaticreconnect_;
  ::PROTOBUF_NAMESPACE_ID::int32 minretryinterval_;
  ::PROTOBUF_NAMESPACE_ID::int32 maxretryinterval_;
  friend struct ::TableStruct_mqtt_5fasync_2eproto;
};
// -------------------------------------------------------------------

class SendMessageEtc PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SendMessageEtc) */ {
 public:
  inline SendMessageEtc() : SendMessageEtc(nullptr) {}
  virtual ~SendMessageEtc();

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

  inline SendMessageEtc& operator=(const SendMessageEtc& from) {
    CopyFrom(from);
    return *this;
  }
  inline SendMessageEtc& operator=(SendMessageEtc&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SendMessageEtc& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SendMessageEtc* internal_default_instance() {
    return reinterpret_cast<const SendMessageEtc*>(
               &_SendMessageEtc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(SendMessageEtc& a, SendMessageEtc& b) {
    a.Swap(&b);
  }
  inline void Swap(SendMessageEtc* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SendMessageEtc* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SendMessageEtc* New() const final {
    return CreateMaybeMessage<SendMessageEtc>(nullptr);
  }

  SendMessageEtc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SendMessageEtc>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SendMessageEtc& from);
  void MergeFrom(const SendMessageEtc& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SendMessageEtc* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SendMessageEtc";
  }
  protected:
  explicit SendMessageEtc(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_mqtt_5fasync_2eproto);
    return ::descriptor_table_mqtt_5fasync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTopicFieldNumber = 1,
    kQosFieldNumber = 2,
  };
  // required string topic = 1;
  bool has_topic() const;
  private:
  bool _internal_has_topic() const;
  public:
  void clear_topic();
  const std::string& topic() const;
  void set_topic(const std::string& value);
  void set_topic(std::string&& value);
  void set_topic(const char* value);
  void set_topic(const char* value, size_t size);
  std::string* mutable_topic();
  std::string* release_topic();
  void set_allocated_topic(std::string* topic);
  private:
  const std::string& _internal_topic() const;
  void _internal_set_topic(const std::string& value);
  std::string* _internal_mutable_topic();
  public:

  // optional int32 qos = 2 [default = 1];
  bool has_qos() const;
  private:
  bool _internal_has_qos() const;
  public:
  void clear_qos();
  ::PROTOBUF_NAMESPACE_ID::int32 qos() const;
  void set_qos(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_qos() const;
  void _internal_set_qos(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
  ::PROTOBUF_NAMESPACE_ID::int32 qos_;
  friend struct ::TableStruct_mqtt_5fasync_2eproto;
};
// -------------------------------------------------------------------

class SubscribeEtc PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SubscribeEtc) */ {
 public:
  inline SubscribeEtc() : SubscribeEtc(nullptr) {}
  virtual ~SubscribeEtc();

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

  inline SubscribeEtc& operator=(const SubscribeEtc& from) {
    CopyFrom(from);
    return *this;
  }
  inline SubscribeEtc& operator=(SubscribeEtc&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SubscribeEtc& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SubscribeEtc* internal_default_instance() {
    return reinterpret_cast<const SubscribeEtc*>(
               &_SubscribeEtc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(SubscribeEtc& a, SubscribeEtc& b) {
    a.Swap(&b);
  }
  inline void Swap(SubscribeEtc* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubscribeEtc* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SubscribeEtc* New() const final {
    return CreateMaybeMessage<SubscribeEtc>(nullptr);
  }

  SubscribeEtc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SubscribeEtc>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SubscribeEtc& from);
  void MergeFrom(const SubscribeEtc& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SubscribeEtc* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SubscribeEtc";
  }
  protected:
  explicit SubscribeEtc(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_mqtt_5fasync_2eproto);
    return ::descriptor_table_mqtt_5fasync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTopicFieldNumber = 1,
    kQosFieldNumber = 2,
  };
  // required string topic = 1;
  bool has_topic() const;
  private:
  bool _internal_has_topic() const;
  public:
  void clear_topic();
  const std::string& topic() const;
  void set_topic(const std::string& value);
  void set_topic(std::string&& value);
  void set_topic(const char* value);
  void set_topic(const char* value, size_t size);
  std::string* mutable_topic();
  std::string* release_topic();
  void set_allocated_topic(std::string* topic);
  private:
  const std::string& _internal_topic() const;
  void _internal_set_topic(const std::string& value);
  std::string* _internal_mutable_topic();
  public:

  // optional int32 qos = 2 [default = 1];
  bool has_qos() const;
  private:
  bool _internal_has_qos() const;
  public:
  void clear_qos();
  ::PROTOBUF_NAMESPACE_ID::int32 qos() const;
  void set_qos(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_qos() const;
  void _internal_set_qos(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
  ::PROTOBUF_NAMESPACE_ID::int32 qos_;
  friend struct ::TableStruct_mqtt_5fasync_2eproto;
};
// -------------------------------------------------------------------

class MqttAsyncConfig PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MqttAsyncConfig) */ {
 public:
  inline MqttAsyncConfig() : MqttAsyncConfig(nullptr) {}
  virtual ~MqttAsyncConfig();

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

  inline MqttAsyncConfig& operator=(const MqttAsyncConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline MqttAsyncConfig& operator=(MqttAsyncConfig&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MqttAsyncConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MqttAsyncConfig* internal_default_instance() {
    return reinterpret_cast<const MqttAsyncConfig*>(
               &_MqttAsyncConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(MqttAsyncConfig& a, MqttAsyncConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(MqttAsyncConfig* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MqttAsyncConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline MqttAsyncConfig* New() const final {
    return CreateMaybeMessage<MqttAsyncConfig>(nullptr);
  }

  MqttAsyncConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MqttAsyncConfig>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MqttAsyncConfig& from);
  void MergeFrom(const MqttAsyncConfig& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MqttAsyncConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MqttAsyncConfig";
  }
  protected:
  explicit MqttAsyncConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_mqtt_5fasync_2eproto);
    return ::descriptor_table_mqtt_5fasync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSendMessageFieldNumber = 5,
    kSubscribeFieldNumber = 6,
    kAddressFieldNumber = 1,
    kClientIdFieldNumber = 2,
    kCreateOptsFieldNumber = 3,
    kConnectOpsFieldNumber = 4,
  };
  // repeated .SendMessageEtc sendMessage = 5;
  int sendmessage_size() const;
  private:
  int _internal_sendmessage_size() const;
  public:
  void clear_sendmessage();
  ::SendMessageEtc* mutable_sendmessage(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SendMessageEtc >*
      mutable_sendmessage();
  private:
  const ::SendMessageEtc& _internal_sendmessage(int index) const;
  ::SendMessageEtc* _internal_add_sendmessage();
  public:
  const ::SendMessageEtc& sendmessage(int index) const;
  ::SendMessageEtc* add_sendmessage();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SendMessageEtc >&
      sendmessage() const;

  // repeated .SubscribeEtc subscribe = 6;
  int subscribe_size() const;
  private:
  int _internal_subscribe_size() const;
  public:
  void clear_subscribe();
  ::SubscribeEtc* mutable_subscribe(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SubscribeEtc >*
      mutable_subscribe();
  private:
  const ::SubscribeEtc& _internal_subscribe(int index) const;
  ::SubscribeEtc* _internal_add_subscribe();
  public:
  const ::SubscribeEtc& subscribe(int index) const;
  ::SubscribeEtc* add_subscribe();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SubscribeEtc >&
      subscribe() const;

  // optional string address = 1 [default = "mqtt://127.0.0.1:1883"];
  bool has_address() const;
  private:
  bool _internal_has_address() const;
  public:
  void clear_address();
  const std::string& address() const;
  void set_address(const std::string& value);
  void set_address(std::string&& value);
  void set_address(const char* value);
  void set_address(const char* value, size_t size);
  std::string* mutable_address();
  std::string* release_address();
  void set_allocated_address(std::string* address);
  private:
  const std::string& _internal_address() const;
  void _internal_set_address(const std::string& value);
  std::string* _internal_mutable_address();
  public:

  // optional string client_id = 2 [default = "Auto"];
  bool has_client_id() const;
  private:
  bool _internal_has_client_id() const;
  public:
  void clear_client_id();
  const std::string& client_id() const;
  void set_client_id(const std::string& value);
  void set_client_id(std::string&& value);
  void set_client_id(const char* value);
  void set_client_id(const char* value, size_t size);
  std::string* mutable_client_id();
  std::string* release_client_id();
  void set_allocated_client_id(std::string* client_id);
  private:
  const std::string& _internal_client_id() const;
  void _internal_set_client_id(const std::string& value);
  std::string* _internal_mutable_client_id();
  public:

  // optional .CreateOpts create_opts = 3;
  bool has_create_opts() const;
  private:
  bool _internal_has_create_opts() const;
  public:
  void clear_create_opts();
  const ::CreateOpts& create_opts() const;
  ::CreateOpts* release_create_opts();
  ::CreateOpts* mutable_create_opts();
  void set_allocated_create_opts(::CreateOpts* create_opts);
  private:
  const ::CreateOpts& _internal_create_opts() const;
  ::CreateOpts* _internal_mutable_create_opts();
  public:
  void unsafe_arena_set_allocated_create_opts(
      ::CreateOpts* create_opts);
  ::CreateOpts* unsafe_arena_release_create_opts();

  // optional .ConnectOps connect_ops = 4;
  bool has_connect_ops() const;
  private:
  bool _internal_has_connect_ops() const;
  public:
  void clear_connect_ops();
  const ::ConnectOps& connect_ops() const;
  ::ConnectOps* release_connect_ops();
  ::ConnectOps* mutable_connect_ops();
  void set_allocated_connect_ops(::ConnectOps* connect_ops);
  private:
  const ::ConnectOps& _internal_connect_ops() const;
  ::ConnectOps* _internal_mutable_connect_ops();
  public:
  void unsafe_arena_set_allocated_connect_ops(
      ::ConnectOps* connect_ops);
  ::ConnectOps* unsafe_arena_release_connect_ops();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SendMessageEtc > sendmessage_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SubscribeEtc > subscribe_;
  public:
  static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> _i_give_permission_to_break_this_code_default_address_;
  private:
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_;
  public:
  static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> _i_give_permission_to_break_this_code_default_client_id_;
  private:
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_id_;
  ::CreateOpts* create_opts_;
  ::ConnectOps* connect_ops_;
  friend struct ::TableStruct_mqtt_5fasync_2eproto;
};
// ===================================================================


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

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

// optional int32 maxBufferedMessages = 3 [default = 10000];
inline bool CreateOpts::_internal_has_maxbufferedmessages() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CreateOpts::has_maxbufferedmessages() const {
  return _internal_has_maxbufferedmessages();
}
inline void CreateOpts::clear_maxbufferedmessages() {
  maxbufferedmessages_ = 10000;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateOpts::_internal_maxbufferedmessages() const {
  return maxbufferedmessages_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateOpts::maxbufferedmessages() const {
  // @@protoc_insertion_point(field_get:CreateOpts.maxBufferedMessages)
  return _internal_maxbufferedmessages();
}
inline void CreateOpts::_internal_set_maxbufferedmessages(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000001u;
  maxbufferedmessages_ = value;
}
inline void CreateOpts::set_maxbufferedmessages(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_maxbufferedmessages(value);
  // @@protoc_insertion_point(field_set:CreateOpts.maxBufferedMessages)
}

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

// ConnectOps

// optional bool cleansession = 1 [default = true];
inline bool ConnectOps::_internal_has_cleansession() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ConnectOps::has_cleansession() const {
  return _internal_has_cleansession();
}
inline void ConnectOps::clear_cleansession() {
  cleansession_ = true;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool ConnectOps::_internal_cleansession() const {
  return cleansession_;
}
inline bool ConnectOps::cleansession() const {
  // @@protoc_insertion_point(field_get:ConnectOps.cleansession)
  return _internal_cleansession();
}
inline void ConnectOps::_internal_set_cleansession(bool value) {
  _has_bits_[0] |= 0x00000002u;
  cleansession_ = value;
}
inline void ConnectOps::set_cleansession(bool value) {
  _internal_set_cleansession(value);
  // @@protoc_insertion_point(field_set:ConnectOps.cleansession)
}

// optional int32 keepAliveInterval = 2 [default = 30];
inline bool ConnectOps::_internal_has_keepaliveinterval() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ConnectOps::has_keepaliveinterval() const {
  return _internal_has_keepaliveinterval();
}
inline void ConnectOps::clear_keepaliveinterval() {
  keepaliveinterval_ = 30;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectOps::_internal_keepaliveinterval() const {
  return keepaliveinterval_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectOps::keepaliveinterval() const {
  // @@protoc_insertion_point(field_get:ConnectOps.keepAliveInterval)
  return _internal_keepaliveinterval();
}
inline void ConnectOps::_internal_set_keepaliveinterval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000001u;
  keepaliveinterval_ = value;
}
inline void ConnectOps::set_keepaliveinterval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_keepaliveinterval(value);
  // @@protoc_insertion_point(field_set:ConnectOps.keepAliveInterval)
}

// optional bool automaticReconnect = 3 [default = true];
inline bool ConnectOps::_internal_has_automaticreconnect() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ConnectOps::has_automaticreconnect() const {
  return _internal_has_automaticreconnect();
}
inline void ConnectOps::clear_automaticreconnect() {
  automaticreconnect_ = true;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool ConnectOps::_internal_automaticreconnect() const {
  return automaticreconnect_;
}
inline bool ConnectOps::automaticreconnect() const {
  // @@protoc_insertion_point(field_get:ConnectOps.automaticReconnect)
  return _internal_automaticreconnect();
}
inline void ConnectOps::_internal_set_automaticreconnect(bool value) {
  _has_bits_[0] |= 0x00000004u;
  automaticreconnect_ = value;
}
inline void ConnectOps::set_automaticreconnect(bool value) {
  _internal_set_automaticreconnect(value);
  // @@protoc_insertion_point(field_set:ConnectOps.automaticReconnect)
}

// optional int32 minRetryInterval = 4 [default = 3];
inline bool ConnectOps::_internal_has_minretryinterval() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ConnectOps::has_minretryinterval() const {
  return _internal_has_minretryinterval();
}
inline void ConnectOps::clear_minretryinterval() {
  minretryinterval_ = 3;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectOps::_internal_minretryinterval() const {
  return minretryinterval_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectOps::minretryinterval() const {
  // @@protoc_insertion_point(field_get:ConnectOps.minRetryInterval)
  return _internal_minretryinterval();
}
inline void ConnectOps::_internal_set_minretryinterval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  minretryinterval_ = value;
}
inline void ConnectOps::set_minretryinterval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_minretryinterval(value);
  // @@protoc_insertion_point(field_set:ConnectOps.minRetryInterval)
}

// optional int32 maxRetryInterval = 5 [default = 10];
inline bool ConnectOps::_internal_has_maxretryinterval() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ConnectOps::has_maxretryinterval() const {
  return _internal_has_maxretryinterval();
}
inline void ConnectOps::clear_maxretryinterval() {
  maxretryinterval_ = 10;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectOps::_internal_maxretryinterval() const {
  return maxretryinterval_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectOps::maxretryinterval() const {
  // @@protoc_insertion_point(field_get:ConnectOps.maxRetryInterval)
  return _internal_maxretryinterval();
}
inline void ConnectOps::_internal_set_maxretryinterval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000010u;
  maxretryinterval_ = value;
}
inline void ConnectOps::set_maxretryinterval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_maxretryinterval(value);
  // @@protoc_insertion_point(field_set:ConnectOps.maxRetryInterval)
}

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

// SendMessageEtc

// required string topic = 1;
inline bool SendMessageEtc::_internal_has_topic() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SendMessageEtc::has_topic() const {
  return _internal_has_topic();
}
inline void SendMessageEtc::clear_topic() {
  topic_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SendMessageEtc::topic() const {
  // @@protoc_insertion_point(field_get:SendMessageEtc.topic)
  return _internal_topic();
}
inline void SendMessageEtc::set_topic(const std::string& value) {
  _internal_set_topic(value);
  // @@protoc_insertion_point(field_set:SendMessageEtc.topic)
}
inline std::string* SendMessageEtc::mutable_topic() {
  // @@protoc_insertion_point(field_mutable:SendMessageEtc.topic)
  return _internal_mutable_topic();
}
inline const std::string& SendMessageEtc::_internal_topic() const {
  return topic_.Get();
}
inline void SendMessageEtc::_internal_set_topic(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  topic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void SendMessageEtc::set_topic(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  topic_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:SendMessageEtc.topic)
}
inline void SendMessageEtc::set_topic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  topic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:SendMessageEtc.topic)
}
inline void SendMessageEtc::set_topic(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  topic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:SendMessageEtc.topic)
}
inline std::string* SendMessageEtc::_internal_mutable_topic() {
  _has_bits_[0] |= 0x00000001u;
  return topic_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* SendMessageEtc::release_topic() {
  // @@protoc_insertion_point(field_release:SendMessageEtc.topic)
  if (!_internal_has_topic()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return topic_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SendMessageEtc::set_allocated_topic(std::string* topic) {
  if (topic != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:SendMessageEtc.topic)
}

// optional int32 qos = 2 [default = 1];
inline bool SendMessageEtc::_internal_has_qos() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SendMessageEtc::has_qos() const {
  return _internal_has_qos();
}
inline void SendMessageEtc::clear_qos() {
  qos_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SendMessageEtc::_internal_qos() const {
  return qos_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SendMessageEtc::qos() const {
  // @@protoc_insertion_point(field_get:SendMessageEtc.qos)
  return _internal_qos();
}
inline void SendMessageEtc::_internal_set_qos(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  qos_ = value;
}
inline void SendMessageEtc::set_qos(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_qos(value);
  // @@protoc_insertion_point(field_set:SendMessageEtc.qos)
}

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

// SubscribeEtc

// required string topic = 1;
inline bool SubscribeEtc::_internal_has_topic() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SubscribeEtc::has_topic() const {
  return _internal_has_topic();
}
inline void SubscribeEtc::clear_topic() {
  topic_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SubscribeEtc::topic() const {
  // @@protoc_insertion_point(field_get:SubscribeEtc.topic)
  return _internal_topic();
}
inline void SubscribeEtc::set_topic(const std::string& value) {
  _internal_set_topic(value);
  // @@protoc_insertion_point(field_set:SubscribeEtc.topic)
}
inline std::string* SubscribeEtc::mutable_topic() {
  // @@protoc_insertion_point(field_mutable:SubscribeEtc.topic)
  return _internal_mutable_topic();
}
inline const std::string& SubscribeEtc::_internal_topic() const {
  return topic_.Get();
}
inline void SubscribeEtc::_internal_set_topic(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  topic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void SubscribeEtc::set_topic(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  topic_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:SubscribeEtc.topic)
}
inline void SubscribeEtc::set_topic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  topic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:SubscribeEtc.topic)
}
inline void SubscribeEtc::set_topic(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  topic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:SubscribeEtc.topic)
}
inline std::string* SubscribeEtc::_internal_mutable_topic() {
  _has_bits_[0] |= 0x00000001u;
  return topic_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* SubscribeEtc::release_topic() {
  // @@protoc_insertion_point(field_release:SubscribeEtc.topic)
  if (!_internal_has_topic()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return topic_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SubscribeEtc::set_allocated_topic(std::string* topic) {
  if (topic != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:SubscribeEtc.topic)
}

// optional int32 qos = 2 [default = 1];
inline bool SubscribeEtc::_internal_has_qos() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SubscribeEtc::has_qos() const {
  return _internal_has_qos();
}
inline void SubscribeEtc::clear_qos() {
  qos_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubscribeEtc::_internal_qos() const {
  return qos_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubscribeEtc::qos() const {
  // @@protoc_insertion_point(field_get:SubscribeEtc.qos)
  return _internal_qos();
}
inline void SubscribeEtc::_internal_set_qos(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  qos_ = value;
}
inline void SubscribeEtc::set_qos(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_qos(value);
  // @@protoc_insertion_point(field_set:SubscribeEtc.qos)
}

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

// MqttAsyncConfig

// optional string address = 1 [default = "mqtt://127.0.0.1:1883"];
inline bool MqttAsyncConfig::_internal_has_address() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MqttAsyncConfig::has_address() const {
  return _internal_has_address();
}
inline void MqttAsyncConfig::clear_address() {
  address_.ClearToDefault(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_address_.get(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MqttAsyncConfig::address() const {
  // @@protoc_insertion_point(field_get:MqttAsyncConfig.address)
  return _internal_address();
}
inline void MqttAsyncConfig::set_address(const std::string& value) {
  _internal_set_address(value);
  // @@protoc_insertion_point(field_set:MqttAsyncConfig.address)
}
inline std::string* MqttAsyncConfig::mutable_address() {
  // @@protoc_insertion_point(field_mutable:MqttAsyncConfig.address)
  return _internal_mutable_address();
}
inline const std::string& MqttAsyncConfig::_internal_address() const {
  return address_.Get();
}
inline void MqttAsyncConfig::_internal_set_address(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  address_.Set(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_address_.get(), value, GetArena());
}
inline void MqttAsyncConfig::set_address(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  address_.Set(
    &::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_address_.get(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:MqttAsyncConfig.address)
}
inline void MqttAsyncConfig::set_address(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  address_.Set(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_address_.get(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:MqttAsyncConfig.address)
}
inline void MqttAsyncConfig::set_address(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  address_.Set(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_address_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:MqttAsyncConfig.address)
}
inline std::string* MqttAsyncConfig::_internal_mutable_address() {
  _has_bits_[0] |= 0x00000001u;
  return address_.Mutable(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_address_.get(), GetArena());
}
inline std::string* MqttAsyncConfig::release_address() {
  // @@protoc_insertion_point(field_release:MqttAsyncConfig.address)
  if (!_internal_has_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return address_.ReleaseNonDefault(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_address_.get(), GetArena());
}
inline void MqttAsyncConfig::set_allocated_address(std::string* address) {
  if (address != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  address_.SetAllocated(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_address_.get(), address,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:MqttAsyncConfig.address)
}

// optional string client_id = 2 [default = "Auto"];
inline bool MqttAsyncConfig::_internal_has_client_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MqttAsyncConfig::has_client_id() const {
  return _internal_has_client_id();
}
inline void MqttAsyncConfig::clear_client_id() {
  client_id_.ClearToDefault(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_client_id_.get(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MqttAsyncConfig::client_id() const {
  // @@protoc_insertion_point(field_get:MqttAsyncConfig.client_id)
  return _internal_client_id();
}
inline void MqttAsyncConfig::set_client_id(const std::string& value) {
  _internal_set_client_id(value);
  // @@protoc_insertion_point(field_set:MqttAsyncConfig.client_id)
}
inline std::string* MqttAsyncConfig::mutable_client_id() {
  // @@protoc_insertion_point(field_mutable:MqttAsyncConfig.client_id)
  return _internal_mutable_client_id();
}
inline const std::string& MqttAsyncConfig::_internal_client_id() const {
  return client_id_.Get();
}
inline void MqttAsyncConfig::_internal_set_client_id(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  client_id_.Set(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_client_id_.get(), value, GetArena());
}
inline void MqttAsyncConfig::set_client_id(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  client_id_.Set(
    &::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_client_id_.get(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:MqttAsyncConfig.client_id)
}
inline void MqttAsyncConfig::set_client_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  client_id_.Set(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_client_id_.get(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:MqttAsyncConfig.client_id)
}
inline void MqttAsyncConfig::set_client_id(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  client_id_.Set(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_client_id_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:MqttAsyncConfig.client_id)
}
inline std::string* MqttAsyncConfig::_internal_mutable_client_id() {
  _has_bits_[0] |= 0x00000002u;
  return client_id_.Mutable(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_client_id_.get(), GetArena());
}
inline std::string* MqttAsyncConfig::release_client_id() {
  // @@protoc_insertion_point(field_release:MqttAsyncConfig.client_id)
  if (!_internal_has_client_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return client_id_.ReleaseNonDefault(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_client_id_.get(), GetArena());
}
inline void MqttAsyncConfig::set_allocated_client_id(std::string* client_id) {
  if (client_id != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  client_id_.SetAllocated(&::MqttAsyncConfig::_i_give_permission_to_break_this_code_default_client_id_.get(), client_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:MqttAsyncConfig.client_id)
}

// optional .CreateOpts create_opts = 3;
inline bool MqttAsyncConfig::_internal_has_create_opts() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || create_opts_ != nullptr);
  return value;
}
inline bool MqttAsyncConfig::has_create_opts() const {
  return _internal_has_create_opts();
}
inline void MqttAsyncConfig::clear_create_opts() {
  if (create_opts_ != nullptr) create_opts_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::CreateOpts& MqttAsyncConfig::_internal_create_opts() const {
  const ::CreateOpts* p = create_opts_;
  return p != nullptr ? *p : *reinterpret_cast<const ::CreateOpts*>(
      &::_CreateOpts_default_instance_);
}
inline const ::CreateOpts& MqttAsyncConfig::create_opts() const {
  // @@protoc_insertion_point(field_get:MqttAsyncConfig.create_opts)
  return _internal_create_opts();
}
inline void MqttAsyncConfig::unsafe_arena_set_allocated_create_opts(
    ::CreateOpts* create_opts) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(create_opts_);
  }
  create_opts_ = create_opts;
  if (create_opts) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MqttAsyncConfig.create_opts)
}
inline ::CreateOpts* MqttAsyncConfig::release_create_opts() {
  _has_bits_[0] &= ~0x00000004u;
  ::CreateOpts* temp = create_opts_;
  create_opts_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::CreateOpts* MqttAsyncConfig::unsafe_arena_release_create_opts() {
  // @@protoc_insertion_point(field_release:MqttAsyncConfig.create_opts)
  _has_bits_[0] &= ~0x00000004u;
  ::CreateOpts* temp = create_opts_;
  create_opts_ = nullptr;
  return temp;
}
inline ::CreateOpts* MqttAsyncConfig::_internal_mutable_create_opts() {
  _has_bits_[0] |= 0x00000004u;
  if (create_opts_ == nullptr) {
    auto* p = CreateMaybeMessage<::CreateOpts>(GetArena());
    create_opts_ = p;
  }
  return create_opts_;
}
inline ::CreateOpts* MqttAsyncConfig::mutable_create_opts() {
  // @@protoc_insertion_point(field_mutable:MqttAsyncConfig.create_opts)
  return _internal_mutable_create_opts();
}
inline void MqttAsyncConfig::set_allocated_create_opts(::CreateOpts* create_opts) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete create_opts_;
  }
  if (create_opts) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(create_opts);
    if (message_arena != submessage_arena) {
      create_opts = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_opts, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  create_opts_ = create_opts;
  // @@protoc_insertion_point(field_set_allocated:MqttAsyncConfig.create_opts)
}

// optional .ConnectOps connect_ops = 4;
inline bool MqttAsyncConfig::_internal_has_connect_ops() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || connect_ops_ != nullptr);
  return value;
}
inline bool MqttAsyncConfig::has_connect_ops() const {
  return _internal_has_connect_ops();
}
inline void MqttAsyncConfig::clear_connect_ops() {
  if (connect_ops_ != nullptr) connect_ops_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::ConnectOps& MqttAsyncConfig::_internal_connect_ops() const {
  const ::ConnectOps* p = connect_ops_;
  return p != nullptr ? *p : *reinterpret_cast<const ::ConnectOps*>(
      &::_ConnectOps_default_instance_);
}
inline const ::ConnectOps& MqttAsyncConfig::connect_ops() const {
  // @@protoc_insertion_point(field_get:MqttAsyncConfig.connect_ops)
  return _internal_connect_ops();
}
inline void MqttAsyncConfig::unsafe_arena_set_allocated_connect_ops(
    ::ConnectOps* connect_ops) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(connect_ops_);
  }
  connect_ops_ = connect_ops;
  if (connect_ops) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MqttAsyncConfig.connect_ops)
}
inline ::ConnectOps* MqttAsyncConfig::release_connect_ops() {
  _has_bits_[0] &= ~0x00000008u;
  ::ConnectOps* temp = connect_ops_;
  connect_ops_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::ConnectOps* MqttAsyncConfig::unsafe_arena_release_connect_ops() {
  // @@protoc_insertion_point(field_release:MqttAsyncConfig.connect_ops)
  _has_bits_[0] &= ~0x00000008u;
  ::ConnectOps* temp = connect_ops_;
  connect_ops_ = nullptr;
  return temp;
}
inline ::ConnectOps* MqttAsyncConfig::_internal_mutable_connect_ops() {
  _has_bits_[0] |= 0x00000008u;
  if (connect_ops_ == nullptr) {
    auto* p = CreateMaybeMessage<::ConnectOps>(GetArena());
    connect_ops_ = p;
  }
  return connect_ops_;
}
inline ::ConnectOps* MqttAsyncConfig::mutable_connect_ops() {
  // @@protoc_insertion_point(field_mutable:MqttAsyncConfig.connect_ops)
  return _internal_mutable_connect_ops();
}
inline void MqttAsyncConfig::set_allocated_connect_ops(::ConnectOps* connect_ops) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete connect_ops_;
  }
  if (connect_ops) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(connect_ops);
    if (message_arena != submessage_arena) {
      connect_ops = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, connect_ops, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  connect_ops_ = connect_ops;
  // @@protoc_insertion_point(field_set_allocated:MqttAsyncConfig.connect_ops)
}

// repeated .SendMessageEtc sendMessage = 5;
inline int MqttAsyncConfig::_internal_sendmessage_size() const {
  return sendmessage_.size();
}
inline int MqttAsyncConfig::sendmessage_size() const {
  return _internal_sendmessage_size();
}
inline void MqttAsyncConfig::clear_sendmessage() {
  sendmessage_.Clear();
}
inline ::SendMessageEtc* MqttAsyncConfig::mutable_sendmessage(int index) {
  // @@protoc_insertion_point(field_mutable:MqttAsyncConfig.sendMessage)
  return sendmessage_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SendMessageEtc >*
MqttAsyncConfig::mutable_sendmessage() {
  // @@protoc_insertion_point(field_mutable_list:MqttAsyncConfig.sendMessage)
  return &sendmessage_;
}
inline const ::SendMessageEtc& MqttAsyncConfig::_internal_sendmessage(int index) const {
  return sendmessage_.Get(index);
}
inline const ::SendMessageEtc& MqttAsyncConfig::sendmessage(int index) const {
  // @@protoc_insertion_point(field_get:MqttAsyncConfig.sendMessage)
  return _internal_sendmessage(index);
}
inline ::SendMessageEtc* MqttAsyncConfig::_internal_add_sendmessage() {
  return sendmessage_.Add();
}
inline ::SendMessageEtc* MqttAsyncConfig::add_sendmessage() {
  // @@protoc_insertion_point(field_add:MqttAsyncConfig.sendMessage)
  return _internal_add_sendmessage();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SendMessageEtc >&
MqttAsyncConfig::sendmessage() const {
  // @@protoc_insertion_point(field_list:MqttAsyncConfig.sendMessage)
  return sendmessage_;
}

// repeated .SubscribeEtc subscribe = 6;
inline int MqttAsyncConfig::_internal_subscribe_size() const {
  return subscribe_.size();
}
inline int MqttAsyncConfig::subscribe_size() const {
  return _internal_subscribe_size();
}
inline void MqttAsyncConfig::clear_subscribe() {
  subscribe_.Clear();
}
inline ::SubscribeEtc* MqttAsyncConfig::mutable_subscribe(int index) {
  // @@protoc_insertion_point(field_mutable:MqttAsyncConfig.subscribe)
  return subscribe_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SubscribeEtc >*
MqttAsyncConfig::mutable_subscribe() {
  // @@protoc_insertion_point(field_mutable_list:MqttAsyncConfig.subscribe)
  return &subscribe_;
}
inline const ::SubscribeEtc& MqttAsyncConfig::_internal_subscribe(int index) const {
  return subscribe_.Get(index);
}
inline const ::SubscribeEtc& MqttAsyncConfig::subscribe(int index) const {
  // @@protoc_insertion_point(field_get:MqttAsyncConfig.subscribe)
  return _internal_subscribe(index);
}
inline ::SubscribeEtc* MqttAsyncConfig::_internal_add_subscribe() {
  return subscribe_.Add();
}
inline ::SubscribeEtc* MqttAsyncConfig::add_subscribe() {
  // @@protoc_insertion_point(field_add:MqttAsyncConfig.subscribe)
  return _internal_add_subscribe();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SubscribeEtc >&
MqttAsyncConfig::subscribe() const {
  // @@protoc_insertion_point(field_list:MqttAsyncConfig.subscribe)
  return subscribe_;
}

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

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