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

#ifndef GOOGLE_PROTOBUF_INCLUDED_dnsmessage_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_dnsmessage_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3008000
#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 3008000 < 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.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_dnsmessage_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_dnsmessage_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
    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_dnsmessage_2eproto;
class PBDNSMessage;
class PBDNSMessageDefaultTypeInternal;
extern PBDNSMessageDefaultTypeInternal _PBDNSMessage_default_instance_;
class PBDNSMessage_DNSQuestion;
class PBDNSMessage_DNSQuestionDefaultTypeInternal;
extern PBDNSMessage_DNSQuestionDefaultTypeInternal _PBDNSMessage_DNSQuestion_default_instance_;
class PBDNSMessage_DNSResponse;
class PBDNSMessage_DNSResponseDefaultTypeInternal;
extern PBDNSMessage_DNSResponseDefaultTypeInternal _PBDNSMessage_DNSResponse_default_instance_;
class PBDNSMessage_DNSResponse_DNSRR;
class PBDNSMessage_DNSResponse_DNSRRDefaultTypeInternal;
extern PBDNSMessage_DNSResponse_DNSRRDefaultTypeInternal _PBDNSMessage_DNSResponse_DNSRR_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::PBDNSMessage* Arena::CreateMaybeMessage<::PBDNSMessage>(Arena*);
template<> ::PBDNSMessage_DNSQuestion* Arena::CreateMaybeMessage<::PBDNSMessage_DNSQuestion>(Arena*);
template<> ::PBDNSMessage_DNSResponse* Arena::CreateMaybeMessage<::PBDNSMessage_DNSResponse>(Arena*);
template<> ::PBDNSMessage_DNSResponse_DNSRR* Arena::CreateMaybeMessage<::PBDNSMessage_DNSResponse_DNSRR>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum PBDNSMessage_Type : int {
  PBDNSMessage_Type_DNSQueryType = 1,
  PBDNSMessage_Type_DNSResponseType = 2,
  PBDNSMessage_Type_DNSOutgoingQueryType = 3,
  PBDNSMessage_Type_DNSIncomingResponseType = 4
};
bool PBDNSMessage_Type_IsValid(int value);
constexpr PBDNSMessage_Type PBDNSMessage_Type_Type_MIN = PBDNSMessage_Type_DNSQueryType;
constexpr PBDNSMessage_Type PBDNSMessage_Type_Type_MAX = PBDNSMessage_Type_DNSIncomingResponseType;
constexpr int PBDNSMessage_Type_Type_ARRAYSIZE = PBDNSMessage_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PBDNSMessage_Type_descriptor();
template<typename T>
inline const std::string& PBDNSMessage_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PBDNSMessage_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PBDNSMessage_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PBDNSMessage_Type_descriptor(), enum_t_value);
}
inline bool PBDNSMessage_Type_Parse(
    const std::string& name, PBDNSMessage_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PBDNSMessage_Type>(
    PBDNSMessage_Type_descriptor(), name, value);
}
enum PBDNSMessage_SocketFamily : int {
  PBDNSMessage_SocketFamily_INET = 1,
  PBDNSMessage_SocketFamily_INET6 = 2
};
bool PBDNSMessage_SocketFamily_IsValid(int value);
constexpr PBDNSMessage_SocketFamily PBDNSMessage_SocketFamily_SocketFamily_MIN = PBDNSMessage_SocketFamily_INET;
constexpr PBDNSMessage_SocketFamily PBDNSMessage_SocketFamily_SocketFamily_MAX = PBDNSMessage_SocketFamily_INET6;
constexpr int PBDNSMessage_SocketFamily_SocketFamily_ARRAYSIZE = PBDNSMessage_SocketFamily_SocketFamily_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PBDNSMessage_SocketFamily_descriptor();
template<typename T>
inline const std::string& PBDNSMessage_SocketFamily_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PBDNSMessage_SocketFamily>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PBDNSMessage_SocketFamily_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PBDNSMessage_SocketFamily_descriptor(), enum_t_value);
}
inline bool PBDNSMessage_SocketFamily_Parse(
    const std::string& name, PBDNSMessage_SocketFamily* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PBDNSMessage_SocketFamily>(
    PBDNSMessage_SocketFamily_descriptor(), name, value);
}
enum PBDNSMessage_SocketProtocol : int {
  PBDNSMessage_SocketProtocol_UDP = 1,
  PBDNSMessage_SocketProtocol_TCP = 2
};
bool PBDNSMessage_SocketProtocol_IsValid(int value);
constexpr PBDNSMessage_SocketProtocol PBDNSMessage_SocketProtocol_SocketProtocol_MIN = PBDNSMessage_SocketProtocol_UDP;
constexpr PBDNSMessage_SocketProtocol PBDNSMessage_SocketProtocol_SocketProtocol_MAX = PBDNSMessage_SocketProtocol_TCP;
constexpr int PBDNSMessage_SocketProtocol_SocketProtocol_ARRAYSIZE = PBDNSMessage_SocketProtocol_SocketProtocol_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PBDNSMessage_SocketProtocol_descriptor();
template<typename T>
inline const std::string& PBDNSMessage_SocketProtocol_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PBDNSMessage_SocketProtocol>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PBDNSMessage_SocketProtocol_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PBDNSMessage_SocketProtocol_descriptor(), enum_t_value);
}
inline bool PBDNSMessage_SocketProtocol_Parse(
    const std::string& name, PBDNSMessage_SocketProtocol* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PBDNSMessage_SocketProtocol>(
    PBDNSMessage_SocketProtocol_descriptor(), name, value);
}
enum PBDNSMessage_PolicyType : int {
  PBDNSMessage_PolicyType_UNKNOWN = 1,
  PBDNSMessage_PolicyType_QNAME = 2,
  PBDNSMessage_PolicyType_CLIENTIP = 3,
  PBDNSMessage_PolicyType_RESPONSEIP = 4,
  PBDNSMessage_PolicyType_NSDNAME = 5,
  PBDNSMessage_PolicyType_NSIP = 6
};
bool PBDNSMessage_PolicyType_IsValid(int value);
constexpr PBDNSMessage_PolicyType PBDNSMessage_PolicyType_PolicyType_MIN = PBDNSMessage_PolicyType_UNKNOWN;
constexpr PBDNSMessage_PolicyType PBDNSMessage_PolicyType_PolicyType_MAX = PBDNSMessage_PolicyType_NSIP;
constexpr int PBDNSMessage_PolicyType_PolicyType_ARRAYSIZE = PBDNSMessage_PolicyType_PolicyType_MAX + 1;

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

class PBDNSMessage_DNSQuestion :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PBDNSMessage.DNSQuestion) */ {
 public:
  PBDNSMessage_DNSQuestion();
  virtual ~PBDNSMessage_DNSQuestion();

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

  inline PBDNSMessage_DNSQuestion& operator=(const PBDNSMessage_DNSQuestion& from) {
    CopyFrom(from);
    return *this;
  }
  inline PBDNSMessage_DNSQuestion& operator=(PBDNSMessage_DNSQuestion&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  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 PBDNSMessage_DNSQuestion& default_instance();

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

  void Swap(PBDNSMessage_DNSQuestion* other);
  friend void swap(PBDNSMessage_DNSQuestion& a, PBDNSMessage_DNSQuestion& b) {
    a.Swap(&b);
  }

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

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

  PBDNSMessage_DNSQuestion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PBDNSMessage_DNSQuestion>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PBDNSMessage_DNSQuestion& from);
  void MergeFrom(const PBDNSMessage_DNSQuestion& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) 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(PBDNSMessage_DNSQuestion* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PBDNSMessage.DNSQuestion";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  // optional string qName = 1;
  bool has_qname() const;
  void clear_qname();
  static const int kQNameFieldNumber = 1;
  const std::string& qname() const;
  void set_qname(const std::string& value);
  void set_qname(std::string&& value);
  void set_qname(const char* value);
  void set_qname(const char* value, size_t size);
  std::string* mutable_qname();
  std::string* release_qname();
  void set_allocated_qname(std::string* qname);

  // optional uint32 qType = 2;
  bool has_qtype() const;
  void clear_qtype();
  static const int kQTypeFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::uint32 qtype() const;
  void set_qtype(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 qClass = 3;
  bool has_qclass() const;
  void clear_qclass();
  static const int kQClassFieldNumber = 3;
  ::PROTOBUF_NAMESPACE_ID::uint32 qclass() const;
  void set_qclass(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:PBDNSMessage.DNSQuestion)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr qname_;
  ::PROTOBUF_NAMESPACE_ID::uint32 qtype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 qclass_;
  friend struct ::TableStruct_dnsmessage_2eproto;
};
// -------------------------------------------------------------------

class PBDNSMessage_DNSResponse_DNSRR :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PBDNSMessage.DNSResponse.DNSRR) */ {
 public:
  PBDNSMessage_DNSResponse_DNSRR();
  virtual ~PBDNSMessage_DNSResponse_DNSRR();

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

  inline PBDNSMessage_DNSResponse_DNSRR& operator=(const PBDNSMessage_DNSResponse_DNSRR& from) {
    CopyFrom(from);
    return *this;
  }
  inline PBDNSMessage_DNSResponse_DNSRR& operator=(PBDNSMessage_DNSResponse_DNSRR&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  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 PBDNSMessage_DNSResponse_DNSRR& default_instance();

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

  void Swap(PBDNSMessage_DNSResponse_DNSRR* other);
  friend void swap(PBDNSMessage_DNSResponse_DNSRR& a, PBDNSMessage_DNSResponse_DNSRR& b) {
    a.Swap(&b);
  }

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

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

  PBDNSMessage_DNSResponse_DNSRR* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PBDNSMessage_DNSResponse_DNSRR>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PBDNSMessage_DNSResponse_DNSRR& from);
  void MergeFrom(const PBDNSMessage_DNSResponse_DNSRR& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) 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(PBDNSMessage_DNSResponse_DNSRR* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PBDNSMessage.DNSResponse.DNSRR";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  // optional string name = 1;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // optional bytes rdata = 5;
  bool has_rdata() const;
  void clear_rdata();
  static const int kRdataFieldNumber = 5;
  const std::string& rdata() const;
  void set_rdata(const std::string& value);
  void set_rdata(std::string&& value);
  void set_rdata(const char* value);
  void set_rdata(const void* value, size_t size);
  std::string* mutable_rdata();
  std::string* release_rdata();
  void set_allocated_rdata(std::string* rdata);

  // optional uint32 type = 2;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::uint32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 class = 3;
  bool has_class_() const;
  void clear_class_();
  static const int kClassFieldNumber = 3;
  ::PROTOBUF_NAMESPACE_ID::uint32 class_() const;
  void set_class_(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 ttl = 4;
  bool has_ttl() const;
  void clear_ttl();
  static const int kTtlFieldNumber = 4;
  ::PROTOBUF_NAMESPACE_ID::uint32 ttl() const;
  void set_ttl(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:PBDNSMessage.DNSResponse.DNSRR)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rdata_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_;
  ::PROTOBUF_NAMESPACE_ID::uint32 class__;
  ::PROTOBUF_NAMESPACE_ID::uint32 ttl_;
  friend struct ::TableStruct_dnsmessage_2eproto;
};
// -------------------------------------------------------------------

class PBDNSMessage_DNSResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PBDNSMessage.DNSResponse) */ {
 public:
  PBDNSMessage_DNSResponse();
  virtual ~PBDNSMessage_DNSResponse();

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

  inline PBDNSMessage_DNSResponse& operator=(const PBDNSMessage_DNSResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PBDNSMessage_DNSResponse& operator=(PBDNSMessage_DNSResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  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 PBDNSMessage_DNSResponse& default_instance();

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

  void Swap(PBDNSMessage_DNSResponse* other);
  friend void swap(PBDNSMessage_DNSResponse& a, PBDNSMessage_DNSResponse& b) {
    a.Swap(&b);
  }

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

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

  PBDNSMessage_DNSResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PBDNSMessage_DNSResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PBDNSMessage_DNSResponse& from);
  void MergeFrom(const PBDNSMessage_DNSResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) 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(PBDNSMessage_DNSResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PBDNSMessage.DNSResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

  typedef PBDNSMessage_DNSResponse_DNSRR DNSRR;

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

  // repeated .PBDNSMessage.DNSResponse.DNSRR rrs = 2;
  int rrs_size() const;
  void clear_rrs();
  static const int kRrsFieldNumber = 2;
  ::PBDNSMessage_DNSResponse_DNSRR* mutable_rrs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PBDNSMessage_DNSResponse_DNSRR >*
      mutable_rrs();
  const ::PBDNSMessage_DNSResponse_DNSRR& rrs(int index) const;
  ::PBDNSMessage_DNSResponse_DNSRR* add_rrs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PBDNSMessage_DNSResponse_DNSRR >&
      rrs() const;

  // repeated string tags = 4;
  int tags_size() const;
  void clear_tags();
  static const int kTagsFieldNumber = 4;
  const std::string& tags(int index) const;
  std::string* mutable_tags(int index);
  void set_tags(int index, const std::string& value);
  void set_tags(int index, std::string&& value);
  void set_tags(int index, const char* value);
  void set_tags(int index, const char* value, size_t size);
  std::string* add_tags();
  void add_tags(const std::string& value);
  void add_tags(std::string&& value);
  void add_tags(const char* value);
  void add_tags(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& tags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_tags();

  // optional string appliedPolicy = 3;
  bool has_appliedpolicy() const;
  void clear_appliedpolicy();
  static const int kAppliedPolicyFieldNumber = 3;
  const std::string& appliedpolicy() const;
  void set_appliedpolicy(const std::string& value);
  void set_appliedpolicy(std::string&& value);
  void set_appliedpolicy(const char* value);
  void set_appliedpolicy(const char* value, size_t size);
  std::string* mutable_appliedpolicy();
  std::string* release_appliedpolicy();
  void set_allocated_appliedpolicy(std::string* appliedpolicy);

  // optional uint32 rcode = 1;
  bool has_rcode() const;
  void clear_rcode();
  static const int kRcodeFieldNumber = 1;
  ::PROTOBUF_NAMESPACE_ID::uint32 rcode() const;
  void set_rcode(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 queryTimeSec = 5;
  bool has_querytimesec() const;
  void clear_querytimesec();
  static const int kQueryTimeSecFieldNumber = 5;
  ::PROTOBUF_NAMESPACE_ID::uint32 querytimesec() const;
  void set_querytimesec(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 queryTimeUsec = 6;
  bool has_querytimeusec() const;
  void clear_querytimeusec();
  static const int kQueryTimeUsecFieldNumber = 6;
  ::PROTOBUF_NAMESPACE_ID::uint32 querytimeusec() const;
  void set_querytimeusec(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional .PBDNSMessage.PolicyType appliedPolicyType = 7;
  bool has_appliedpolicytype() const;
  void clear_appliedpolicytype();
  static const int kAppliedPolicyTypeFieldNumber = 7;
  ::PBDNSMessage_PolicyType appliedpolicytype() const;
  void set_appliedpolicytype(::PBDNSMessage_PolicyType value);

  // @@protoc_insertion_point(class_scope:PBDNSMessage.DNSResponse)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PBDNSMessage_DNSResponse_DNSRR > rrs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> tags_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr appliedpolicy_;
  ::PROTOBUF_NAMESPACE_ID::uint32 rcode_;
  ::PROTOBUF_NAMESPACE_ID::uint32 querytimesec_;
  ::PROTOBUF_NAMESPACE_ID::uint32 querytimeusec_;
  int appliedpolicytype_;
  friend struct ::TableStruct_dnsmessage_2eproto;
};
// -------------------------------------------------------------------

class PBDNSMessage :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PBDNSMessage) */ {
 public:
  PBDNSMessage();
  virtual ~PBDNSMessage();

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

  inline PBDNSMessage& operator=(const PBDNSMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline PBDNSMessage& operator=(PBDNSMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  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 PBDNSMessage& default_instance();

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

  void Swap(PBDNSMessage* other);
  friend void swap(PBDNSMessage& a, PBDNSMessage& b) {
    a.Swap(&b);
  }

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

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

  PBDNSMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PBDNSMessage>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PBDNSMessage& from);
  void MergeFrom(const PBDNSMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) 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(PBDNSMessage* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PBDNSMessage";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

  typedef PBDNSMessage_DNSQuestion DNSQuestion;
  typedef PBDNSMessage_DNSResponse DNSResponse;

  typedef PBDNSMessage_Type Type;
  static constexpr Type DNSQueryType =
    PBDNSMessage_Type_DNSQueryType;
  static constexpr Type DNSResponseType =
    PBDNSMessage_Type_DNSResponseType;
  static constexpr Type DNSOutgoingQueryType =
    PBDNSMessage_Type_DNSOutgoingQueryType;
  static constexpr Type DNSIncomingResponseType =
    PBDNSMessage_Type_DNSIncomingResponseType;
  static inline bool Type_IsValid(int value) {
    return PBDNSMessage_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    PBDNSMessage_Type_Type_MIN;
  static constexpr Type Type_MAX =
    PBDNSMessage_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    PBDNSMessage_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return PBDNSMessage_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 PBDNSMessage_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(const std::string& name,
      Type* value) {
    return PBDNSMessage_Type_Parse(name, value);
  }

  typedef PBDNSMessage_SocketFamily SocketFamily;
  static constexpr SocketFamily INET =
    PBDNSMessage_SocketFamily_INET;
  static constexpr SocketFamily INET6 =
    PBDNSMessage_SocketFamily_INET6;
  static inline bool SocketFamily_IsValid(int value) {
    return PBDNSMessage_SocketFamily_IsValid(value);
  }
  static constexpr SocketFamily SocketFamily_MIN =
    PBDNSMessage_SocketFamily_SocketFamily_MIN;
  static constexpr SocketFamily SocketFamily_MAX =
    PBDNSMessage_SocketFamily_SocketFamily_MAX;
  static constexpr int SocketFamily_ARRAYSIZE =
    PBDNSMessage_SocketFamily_SocketFamily_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SocketFamily_descriptor() {
    return PBDNSMessage_SocketFamily_descriptor();
  }
  template<typename T>
  static inline const std::string& SocketFamily_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SocketFamily>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SocketFamily_Name.");
    return PBDNSMessage_SocketFamily_Name(enum_t_value);
  }
  static inline bool SocketFamily_Parse(const std::string& name,
      SocketFamily* value) {
    return PBDNSMessage_SocketFamily_Parse(name, value);
  }

  typedef PBDNSMessage_SocketProtocol SocketProtocol;
  static constexpr SocketProtocol UDP =
    PBDNSMessage_SocketProtocol_UDP;
  static constexpr SocketProtocol TCP =
    PBDNSMessage_SocketProtocol_TCP;
  static inline bool SocketProtocol_IsValid(int value) {
    return PBDNSMessage_SocketProtocol_IsValid(value);
  }
  static constexpr SocketProtocol SocketProtocol_MIN =
    PBDNSMessage_SocketProtocol_SocketProtocol_MIN;
  static constexpr SocketProtocol SocketProtocol_MAX =
    PBDNSMessage_SocketProtocol_SocketProtocol_MAX;
  static constexpr int SocketProtocol_ARRAYSIZE =
    PBDNSMessage_SocketProtocol_SocketProtocol_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SocketProtocol_descriptor() {
    return PBDNSMessage_SocketProtocol_descriptor();
  }
  template<typename T>
  static inline const std::string& SocketProtocol_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SocketProtocol>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SocketProtocol_Name.");
    return PBDNSMessage_SocketProtocol_Name(enum_t_value);
  }
  static inline bool SocketProtocol_Parse(const std::string& name,
      SocketProtocol* value) {
    return PBDNSMessage_SocketProtocol_Parse(name, value);
  }

  typedef PBDNSMessage_PolicyType PolicyType;
  static constexpr PolicyType UNKNOWN =
    PBDNSMessage_PolicyType_UNKNOWN;
  static constexpr PolicyType QNAME =
    PBDNSMessage_PolicyType_QNAME;
  static constexpr PolicyType CLIENTIP =
    PBDNSMessage_PolicyType_CLIENTIP;
  static constexpr PolicyType RESPONSEIP =
    PBDNSMessage_PolicyType_RESPONSEIP;
  static constexpr PolicyType NSDNAME =
    PBDNSMessage_PolicyType_NSDNAME;
  static constexpr PolicyType NSIP =
    PBDNSMessage_PolicyType_NSIP;
  static inline bool PolicyType_IsValid(int value) {
    return PBDNSMessage_PolicyType_IsValid(value);
  }
  static constexpr PolicyType PolicyType_MIN =
    PBDNSMessage_PolicyType_PolicyType_MIN;
  static constexpr PolicyType PolicyType_MAX =
    PBDNSMessage_PolicyType_PolicyType_MAX;
  static constexpr int PolicyType_ARRAYSIZE =
    PBDNSMessage_PolicyType_PolicyType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PolicyType_descriptor() {
    return PBDNSMessage_PolicyType_descriptor();
  }
  template<typename T>
  static inline const std::string& PolicyType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PolicyType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PolicyType_Name.");
    return PBDNSMessage_PolicyType_Name(enum_t_value);
  }
  static inline bool PolicyType_Parse(const std::string& name,
      PolicyType* value) {
    return PBDNSMessage_PolicyType_Parse(name, value);
  }

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

  // optional bytes messageId = 2;
  bool has_messageid() const;
  void clear_messageid();
  static const int kMessageIdFieldNumber = 2;
  const std::string& messageid() const;
  void set_messageid(const std::string& value);
  void set_messageid(std::string&& value);
  void set_messageid(const char* value);
  void set_messageid(const void* value, size_t size);
  std::string* mutable_messageid();
  std::string* release_messageid();
  void set_allocated_messageid(std::string* messageid);

  // optional bytes serverIdentity = 3;
  bool has_serveridentity() const;
  void clear_serveridentity();
  static const int kServerIdentityFieldNumber = 3;
  const std::string& serveridentity() const;
  void set_serveridentity(const std::string& value);
  void set_serveridentity(std::string&& value);
  void set_serveridentity(const char* value);
  void set_serveridentity(const void* value, size_t size);
  std::string* mutable_serveridentity();
  std::string* release_serveridentity();
  void set_allocated_serveridentity(std::string* serveridentity);

  // optional bytes from = 6;
  bool has_from() const;
  void clear_from();
  static const int kFromFieldNumber = 6;
  const std::string& from() const;
  void set_from(const std::string& value);
  void set_from(std::string&& value);
  void set_from(const char* value);
  void set_from(const void* value, size_t size);
  std::string* mutable_from();
  std::string* release_from();
  void set_allocated_from(std::string* from);

  // optional bytes to = 7;
  bool has_to() const;
  void clear_to();
  static const int kToFieldNumber = 7;
  const std::string& to() const;
  void set_to(const std::string& value);
  void set_to(std::string&& value);
  void set_to(const char* value);
  void set_to(const void* value, size_t size);
  std::string* mutable_to();
  std::string* release_to();
  void set_allocated_to(std::string* to);

  // optional bytes originalRequestorSubnet = 14;
  bool has_originalrequestorsubnet() const;
  void clear_originalrequestorsubnet();
  static const int kOriginalRequestorSubnetFieldNumber = 14;
  const std::string& originalrequestorsubnet() const;
  void set_originalrequestorsubnet(const std::string& value);
  void set_originalrequestorsubnet(std::string&& value);
  void set_originalrequestorsubnet(const char* value);
  void set_originalrequestorsubnet(const void* value, size_t size);
  std::string* mutable_originalrequestorsubnet();
  std::string* release_originalrequestorsubnet();
  void set_allocated_originalrequestorsubnet(std::string* originalrequestorsubnet);

  // optional string requestorId = 15;
  bool has_requestorid() const;
  void clear_requestorid();
  static const int kRequestorIdFieldNumber = 15;
  const std::string& requestorid() const;
  void set_requestorid(const std::string& value);
  void set_requestorid(std::string&& value);
  void set_requestorid(const char* value);
  void set_requestorid(const char* value, size_t size);
  std::string* mutable_requestorid();
  std::string* release_requestorid();
  void set_allocated_requestorid(std::string* requestorid);

  // optional bytes initialRequestId = 16;
  bool has_initialrequestid() const;
  void clear_initialrequestid();
  static const int kInitialRequestIdFieldNumber = 16;
  const std::string& initialrequestid() const;
  void set_initialrequestid(const std::string& value);
  void set_initialrequestid(std::string&& value);
  void set_initialrequestid(const char* value);
  void set_initialrequestid(const void* value, size_t size);
  std::string* mutable_initialrequestid();
  std::string* release_initialrequestid();
  void set_allocated_initialrequestid(std::string* initialrequestid);

  // optional bytes deviceId = 17;
  bool has_deviceid() const;
  void clear_deviceid();
  static const int kDeviceIdFieldNumber = 17;
  const std::string& deviceid() const;
  void set_deviceid(const std::string& value);
  void set_deviceid(std::string&& value);
  void set_deviceid(const char* value);
  void set_deviceid(const void* value, size_t size);
  std::string* mutable_deviceid();
  std::string* release_deviceid();
  void set_allocated_deviceid(std::string* deviceid);

  // optional .PBDNSMessage.DNSQuestion question = 12;
  bool has_question() const;
  void clear_question();
  static const int kQuestionFieldNumber = 12;
  const ::PBDNSMessage_DNSQuestion& question() const;
  ::PBDNSMessage_DNSQuestion* release_question();
  ::PBDNSMessage_DNSQuestion* mutable_question();
  void set_allocated_question(::PBDNSMessage_DNSQuestion* question);

  // optional .PBDNSMessage.DNSResponse response = 13;
  bool has_response() const;
  void clear_response();
  static const int kResponseFieldNumber = 13;
  const ::PBDNSMessage_DNSResponse& response() const;
  ::PBDNSMessage_DNSResponse* release_response();
  ::PBDNSMessage_DNSResponse* mutable_response();
  void set_allocated_response(::PBDNSMessage_DNSResponse* response);

  // optional uint64 inBytes = 8;
  bool has_inbytes() const;
  void clear_inbytes();
  static const int kInBytesFieldNumber = 8;
  ::PROTOBUF_NAMESPACE_ID::uint64 inbytes() const;
  void set_inbytes(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint32 timeSec = 9;
  bool has_timesec() const;
  void clear_timesec();
  static const int kTimeSecFieldNumber = 9;
  ::PROTOBUF_NAMESPACE_ID::uint32 timesec() const;
  void set_timesec(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 timeUsec = 10;
  bool has_timeusec() const;
  void clear_timeusec();
  static const int kTimeUsecFieldNumber = 10;
  ::PROTOBUF_NAMESPACE_ID::uint32 timeusec() const;
  void set_timeusec(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 id = 11;
  bool has_id() const;
  void clear_id();
  static const int kIdFieldNumber = 11;
  ::PROTOBUF_NAMESPACE_ID::uint32 id() const;
  void set_id(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional .PBDNSMessage.SocketProtocol socketProtocol = 5;
  bool has_socketprotocol() const;
  void clear_socketprotocol();
  static const int kSocketProtocolFieldNumber = 5;
  ::PBDNSMessage_SocketProtocol socketprotocol() const;
  void set_socketprotocol(::PBDNSMessage_SocketProtocol value);

  // required .PBDNSMessage.Type type = 1;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::PBDNSMessage_Type type() const;
  void set_type(::PBDNSMessage_Type value);

  // optional .PBDNSMessage.SocketFamily socketFamily = 4;
  bool has_socketfamily() const;
  void clear_socketfamily();
  static const int kSocketFamilyFieldNumber = 4;
  ::PBDNSMessage_SocketFamily socketfamily() const;
  void set_socketfamily(::PBDNSMessage_SocketFamily value);

  // @@protoc_insertion_point(class_scope:PBDNSMessage)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serveridentity_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr from_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr to_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalrequestorsubnet_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestorid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr initialrequestid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceid_;
  ::PBDNSMessage_DNSQuestion* question_;
  ::PBDNSMessage_DNSResponse* response_;
  ::PROTOBUF_NAMESPACE_ID::uint64 inbytes_;
  ::PROTOBUF_NAMESPACE_ID::uint32 timesec_;
  ::PROTOBUF_NAMESPACE_ID::uint32 timeusec_;
  ::PROTOBUF_NAMESPACE_ID::uint32 id_;
  int socketprotocol_;
  int type_;
  int socketfamily_;
  friend struct ::TableStruct_dnsmessage_2eproto;
};
// ===================================================================


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

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

// optional string qName = 1;
inline bool PBDNSMessage_DNSQuestion::has_qname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PBDNSMessage_DNSQuestion::clear_qname() {
  qname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PBDNSMessage_DNSQuestion::qname() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSQuestion.qName)
  return qname_.GetNoArena();
}
inline void PBDNSMessage_DNSQuestion::set_qname(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  qname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSQuestion.qName)
}
inline void PBDNSMessage_DNSQuestion::set_qname(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  qname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.DNSQuestion.qName)
}
inline void PBDNSMessage_DNSQuestion::set_qname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  qname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.DNSQuestion.qName)
}
inline void PBDNSMessage_DNSQuestion::set_qname(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  qname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.DNSQuestion.qName)
}
inline std::string* PBDNSMessage_DNSQuestion::mutable_qname() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.DNSQuestion.qName)
  return qname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage_DNSQuestion::release_qname() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.DNSQuestion.qName)
  if (!has_qname()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return qname_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage_DNSQuestion::set_allocated_qname(std::string* qname) {
  if (qname != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  qname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), qname);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.DNSQuestion.qName)
}

// optional uint32 qType = 2;
inline bool PBDNSMessage_DNSQuestion::has_qtype() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PBDNSMessage_DNSQuestion::clear_qtype() {
  qtype_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage_DNSQuestion::qtype() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSQuestion.qType)
  return qtype_;
}
inline void PBDNSMessage_DNSQuestion::set_qtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  qtype_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSQuestion.qType)
}

// optional uint32 qClass = 3;
inline bool PBDNSMessage_DNSQuestion::has_qclass() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PBDNSMessage_DNSQuestion::clear_qclass() {
  qclass_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage_DNSQuestion::qclass() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSQuestion.qClass)
  return qclass_;
}
inline void PBDNSMessage_DNSQuestion::set_qclass(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  qclass_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSQuestion.qClass)
}

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

// PBDNSMessage_DNSResponse_DNSRR

// optional string name = 1;
inline bool PBDNSMessage_DNSResponse_DNSRR::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PBDNSMessage_DNSResponse_DNSRR::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PBDNSMessage_DNSResponse_DNSRR::name() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.DNSRR.name)
  return name_.GetNoArena();
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.DNSRR.name)
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.DNSResponse.DNSRR.name)
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.DNSResponse.DNSRR.name)
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.DNSResponse.DNSRR.name)
}
inline std::string* PBDNSMessage_DNSResponse_DNSRR::mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.DNSResponse.DNSRR.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage_DNSResponse_DNSRR::release_name() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.DNSResponse.DNSRR.name)
  if (!has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.DNSResponse.DNSRR.name)
}

// optional uint32 type = 2;
inline bool PBDNSMessage_DNSResponse_DNSRR::has_type() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PBDNSMessage_DNSResponse_DNSRR::clear_type() {
  type_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage_DNSResponse_DNSRR::type() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.DNSRR.type)
  return type_;
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  type_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.DNSRR.type)
}

// optional uint32 class = 3;
inline bool PBDNSMessage_DNSResponse_DNSRR::has_class_() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PBDNSMessage_DNSResponse_DNSRR::clear_class_() {
  class__ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage_DNSResponse_DNSRR::class_() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.DNSRR.class)
  return class__;
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_class_(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  class__ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.DNSRR.class)
}

// optional uint32 ttl = 4;
inline bool PBDNSMessage_DNSResponse_DNSRR::has_ttl() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PBDNSMessage_DNSResponse_DNSRR::clear_ttl() {
  ttl_ = 0u;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage_DNSResponse_DNSRR::ttl() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.DNSRR.ttl)
  return ttl_;
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_ttl(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000010u;
  ttl_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.DNSRR.ttl)
}

// optional bytes rdata = 5;
inline bool PBDNSMessage_DNSResponse_DNSRR::has_rdata() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PBDNSMessage_DNSResponse_DNSRR::clear_rdata() {
  rdata_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PBDNSMessage_DNSResponse_DNSRR::rdata() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.DNSRR.rdata)
  return rdata_.GetNoArena();
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_rdata(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  rdata_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.DNSRR.rdata)
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_rdata(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  rdata_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.DNSResponse.DNSRR.rdata)
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_rdata(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  rdata_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.DNSResponse.DNSRR.rdata)
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_rdata(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  rdata_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.DNSResponse.DNSRR.rdata)
}
inline std::string* PBDNSMessage_DNSResponse_DNSRR::mutable_rdata() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.DNSResponse.DNSRR.rdata)
  return rdata_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage_DNSResponse_DNSRR::release_rdata() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.DNSResponse.DNSRR.rdata)
  if (!has_rdata()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return rdata_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage_DNSResponse_DNSRR::set_allocated_rdata(std::string* rdata) {
  if (rdata != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  rdata_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rdata);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.DNSResponse.DNSRR.rdata)
}

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

// PBDNSMessage_DNSResponse

// optional uint32 rcode = 1;
inline bool PBDNSMessage_DNSResponse::has_rcode() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PBDNSMessage_DNSResponse::clear_rcode() {
  rcode_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage_DNSResponse::rcode() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.rcode)
  return rcode_;
}
inline void PBDNSMessage_DNSResponse::set_rcode(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  rcode_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.rcode)
}

// repeated .PBDNSMessage.DNSResponse.DNSRR rrs = 2;
inline int PBDNSMessage_DNSResponse::rrs_size() const {
  return rrs_.size();
}
inline void PBDNSMessage_DNSResponse::clear_rrs() {
  rrs_.Clear();
}
inline ::PBDNSMessage_DNSResponse_DNSRR* PBDNSMessage_DNSResponse::mutable_rrs(int index) {
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.DNSResponse.rrs)
  return rrs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PBDNSMessage_DNSResponse_DNSRR >*
PBDNSMessage_DNSResponse::mutable_rrs() {
  // @@protoc_insertion_point(field_mutable_list:PBDNSMessage.DNSResponse.rrs)
  return &rrs_;
}
inline const ::PBDNSMessage_DNSResponse_DNSRR& PBDNSMessage_DNSResponse::rrs(int index) const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.rrs)
  return rrs_.Get(index);
}
inline ::PBDNSMessage_DNSResponse_DNSRR* PBDNSMessage_DNSResponse::add_rrs() {
  // @@protoc_insertion_point(field_add:PBDNSMessage.DNSResponse.rrs)
  return rrs_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PBDNSMessage_DNSResponse_DNSRR >&
PBDNSMessage_DNSResponse::rrs() const {
  // @@protoc_insertion_point(field_list:PBDNSMessage.DNSResponse.rrs)
  return rrs_;
}

// optional string appliedPolicy = 3;
inline bool PBDNSMessage_DNSResponse::has_appliedpolicy() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PBDNSMessage_DNSResponse::clear_appliedpolicy() {
  appliedpolicy_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PBDNSMessage_DNSResponse::appliedpolicy() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.appliedPolicy)
  return appliedpolicy_.GetNoArena();
}
inline void PBDNSMessage_DNSResponse::set_appliedpolicy(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  appliedpolicy_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.appliedPolicy)
}
inline void PBDNSMessage_DNSResponse::set_appliedpolicy(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  appliedpolicy_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.DNSResponse.appliedPolicy)
}
inline void PBDNSMessage_DNSResponse::set_appliedpolicy(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  appliedpolicy_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.DNSResponse.appliedPolicy)
}
inline void PBDNSMessage_DNSResponse::set_appliedpolicy(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  appliedpolicy_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.DNSResponse.appliedPolicy)
}
inline std::string* PBDNSMessage_DNSResponse::mutable_appliedpolicy() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.DNSResponse.appliedPolicy)
  return appliedpolicy_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage_DNSResponse::release_appliedpolicy() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.DNSResponse.appliedPolicy)
  if (!has_appliedpolicy()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return appliedpolicy_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage_DNSResponse::set_allocated_appliedpolicy(std::string* appliedpolicy) {
  if (appliedpolicy != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  appliedpolicy_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), appliedpolicy);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.DNSResponse.appliedPolicy)
}

// repeated string tags = 4;
inline int PBDNSMessage_DNSResponse::tags_size() const {
  return tags_.size();
}
inline void PBDNSMessage_DNSResponse::clear_tags() {
  tags_.Clear();
}
inline const std::string& PBDNSMessage_DNSResponse::tags(int index) const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.tags)
  return tags_.Get(index);
}
inline std::string* PBDNSMessage_DNSResponse::mutable_tags(int index) {
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.DNSResponse.tags)
  return tags_.Mutable(index);
}
inline void PBDNSMessage_DNSResponse::set_tags(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.tags)
  tags_.Mutable(index)->assign(value);
}
inline void PBDNSMessage_DNSResponse::set_tags(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.tags)
  tags_.Mutable(index)->assign(std::move(value));
}
inline void PBDNSMessage_DNSResponse::set_tags(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  tags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.DNSResponse.tags)
}
inline void PBDNSMessage_DNSResponse::set_tags(int index, const char* value, size_t size) {
  tags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.DNSResponse.tags)
}
inline std::string* PBDNSMessage_DNSResponse::add_tags() {
  // @@protoc_insertion_point(field_add_mutable:PBDNSMessage.DNSResponse.tags)
  return tags_.Add();
}
inline void PBDNSMessage_DNSResponse::add_tags(const std::string& value) {
  tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:PBDNSMessage.DNSResponse.tags)
}
inline void PBDNSMessage_DNSResponse::add_tags(std::string&& value) {
  tags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:PBDNSMessage.DNSResponse.tags)
}
inline void PBDNSMessage_DNSResponse::add_tags(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:PBDNSMessage.DNSResponse.tags)
}
inline void PBDNSMessage_DNSResponse::add_tags(const char* value, size_t size) {
  tags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:PBDNSMessage.DNSResponse.tags)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
PBDNSMessage_DNSResponse::tags() const {
  // @@protoc_insertion_point(field_list:PBDNSMessage.DNSResponse.tags)
  return tags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
PBDNSMessage_DNSResponse::mutable_tags() {
  // @@protoc_insertion_point(field_mutable_list:PBDNSMessage.DNSResponse.tags)
  return &tags_;
}

// optional uint32 queryTimeSec = 5;
inline bool PBDNSMessage_DNSResponse::has_querytimesec() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PBDNSMessage_DNSResponse::clear_querytimesec() {
  querytimesec_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage_DNSResponse::querytimesec() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.queryTimeSec)
  return querytimesec_;
}
inline void PBDNSMessage_DNSResponse::set_querytimesec(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  querytimesec_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.queryTimeSec)
}

// optional uint32 queryTimeUsec = 6;
inline bool PBDNSMessage_DNSResponse::has_querytimeusec() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PBDNSMessage_DNSResponse::clear_querytimeusec() {
  querytimeusec_ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage_DNSResponse::querytimeusec() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.queryTimeUsec)
  return querytimeusec_;
}
inline void PBDNSMessage_DNSResponse::set_querytimeusec(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  querytimeusec_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.queryTimeUsec)
}

// optional .PBDNSMessage.PolicyType appliedPolicyType = 7;
inline bool PBDNSMessage_DNSResponse::has_appliedpolicytype() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PBDNSMessage_DNSResponse::clear_appliedpolicytype() {
  appliedpolicytype_ = 1;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PBDNSMessage_PolicyType PBDNSMessage_DNSResponse::appliedpolicytype() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.DNSResponse.appliedPolicyType)
  return static_cast< ::PBDNSMessage_PolicyType >(appliedpolicytype_);
}
inline void PBDNSMessage_DNSResponse::set_appliedpolicytype(::PBDNSMessage_PolicyType value) {
  assert(::PBDNSMessage_PolicyType_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  appliedpolicytype_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.DNSResponse.appliedPolicyType)
}

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

// PBDNSMessage

// required .PBDNSMessage.Type type = 1;
inline bool PBDNSMessage::has_type() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void PBDNSMessage::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00008000u;
}
inline ::PBDNSMessage_Type PBDNSMessage::type() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.type)
  return static_cast< ::PBDNSMessage_Type >(type_);
}
inline void PBDNSMessage::set_type(::PBDNSMessage_Type value) {
  assert(::PBDNSMessage_Type_IsValid(value));
  _has_bits_[0] |= 0x00008000u;
  type_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.type)
}

// optional bytes messageId = 2;
inline bool PBDNSMessage::has_messageid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PBDNSMessage::clear_messageid() {
  messageid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PBDNSMessage::messageid() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.messageId)
  return messageid_.GetNoArena();
}
inline void PBDNSMessage::set_messageid(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  messageid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.messageId)
}
inline void PBDNSMessage::set_messageid(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  messageid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.messageId)
}
inline void PBDNSMessage::set_messageid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  messageid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.messageId)
}
inline void PBDNSMessage::set_messageid(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  messageid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.messageId)
}
inline std::string* PBDNSMessage::mutable_messageid() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.messageId)
  return messageid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage::release_messageid() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.messageId)
  if (!has_messageid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return messageid_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage::set_allocated_messageid(std::string* messageid) {
  if (messageid != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  messageid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), messageid);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.messageId)
}

// optional bytes serverIdentity = 3;
inline bool PBDNSMessage::has_serveridentity() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PBDNSMessage::clear_serveridentity() {
  serveridentity_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PBDNSMessage::serveridentity() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.serverIdentity)
  return serveridentity_.GetNoArena();
}
inline void PBDNSMessage::set_serveridentity(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  serveridentity_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.serverIdentity)
}
inline void PBDNSMessage::set_serveridentity(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  serveridentity_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.serverIdentity)
}
inline void PBDNSMessage::set_serveridentity(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  serveridentity_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.serverIdentity)
}
inline void PBDNSMessage::set_serveridentity(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  serveridentity_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.serverIdentity)
}
inline std::string* PBDNSMessage::mutable_serveridentity() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.serverIdentity)
  return serveridentity_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage::release_serveridentity() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.serverIdentity)
  if (!has_serveridentity()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return serveridentity_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage::set_allocated_serveridentity(std::string* serveridentity) {
  if (serveridentity != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  serveridentity_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), serveridentity);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.serverIdentity)
}

// optional .PBDNSMessage.SocketFamily socketFamily = 4;
inline bool PBDNSMessage::has_socketfamily() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void PBDNSMessage::clear_socketfamily() {
  socketfamily_ = 1;
  _has_bits_[0] &= ~0x00010000u;
}
inline ::PBDNSMessage_SocketFamily PBDNSMessage::socketfamily() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.socketFamily)
  return static_cast< ::PBDNSMessage_SocketFamily >(socketfamily_);
}
inline void PBDNSMessage::set_socketfamily(::PBDNSMessage_SocketFamily value) {
  assert(::PBDNSMessage_SocketFamily_IsValid(value));
  _has_bits_[0] |= 0x00010000u;
  socketfamily_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.socketFamily)
}

// optional .PBDNSMessage.SocketProtocol socketProtocol = 5;
inline bool PBDNSMessage::has_socketprotocol() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void PBDNSMessage::clear_socketprotocol() {
  socketprotocol_ = 1;
  _has_bits_[0] &= ~0x00004000u;
}
inline ::PBDNSMessage_SocketProtocol PBDNSMessage::socketprotocol() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.socketProtocol)
  return static_cast< ::PBDNSMessage_SocketProtocol >(socketprotocol_);
}
inline void PBDNSMessage::set_socketprotocol(::PBDNSMessage_SocketProtocol value) {
  assert(::PBDNSMessage_SocketProtocol_IsValid(value));
  _has_bits_[0] |= 0x00004000u;
  socketprotocol_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.socketProtocol)
}

// optional bytes from = 6;
inline bool PBDNSMessage::has_from() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PBDNSMessage::clear_from() {
  from_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& PBDNSMessage::from() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.from)
  return from_.GetNoArena();
}
inline void PBDNSMessage::set_from(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  from_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.from)
}
inline void PBDNSMessage::set_from(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  from_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.from)
}
inline void PBDNSMessage::set_from(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  from_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.from)
}
inline void PBDNSMessage::set_from(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000004u;
  from_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.from)
}
inline std::string* PBDNSMessage::mutable_from() {
  _has_bits_[0] |= 0x00000004u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.from)
  return from_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage::release_from() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.from)
  if (!has_from()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return from_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage::set_allocated_from(std::string* from) {
  if (from != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  from_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.from)
}

// optional bytes to = 7;
inline bool PBDNSMessage::has_to() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PBDNSMessage::clear_to() {
  to_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& PBDNSMessage::to() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.to)
  return to_.GetNoArena();
}
inline void PBDNSMessage::set_to(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  to_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.to)
}
inline void PBDNSMessage::set_to(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  to_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.to)
}
inline void PBDNSMessage::set_to(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  to_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.to)
}
inline void PBDNSMessage::set_to(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000008u;
  to_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.to)
}
inline std::string* PBDNSMessage::mutable_to() {
  _has_bits_[0] |= 0x00000008u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.to)
  return to_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage::release_to() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.to)
  if (!has_to()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return to_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage::set_allocated_to(std::string* to) {
  if (to != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  to_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), to);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.to)
}

// optional uint64 inBytes = 8;
inline bool PBDNSMessage::has_inbytes() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void PBDNSMessage::clear_inbytes() {
  inbytes_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 PBDNSMessage::inbytes() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.inBytes)
  return inbytes_;
}
inline void PBDNSMessage::set_inbytes(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000400u;
  inbytes_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.inBytes)
}

// optional uint32 timeSec = 9;
inline bool PBDNSMessage::has_timesec() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void PBDNSMessage::clear_timesec() {
  timesec_ = 0u;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage::timesec() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.timeSec)
  return timesec_;
}
inline void PBDNSMessage::set_timesec(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000800u;
  timesec_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.timeSec)
}

// optional uint32 timeUsec = 10;
inline bool PBDNSMessage::has_timeusec() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void PBDNSMessage::clear_timeusec() {
  timeusec_ = 0u;
  _has_bits_[0] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage::timeusec() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.timeUsec)
  return timeusec_;
}
inline void PBDNSMessage::set_timeusec(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00001000u;
  timeusec_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.timeUsec)
}

// optional uint32 id = 11;
inline bool PBDNSMessage::has_id() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void PBDNSMessage::clear_id() {
  id_ = 0u;
  _has_bits_[0] &= ~0x00002000u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PBDNSMessage::id() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.id)
  return id_;
}
inline void PBDNSMessage::set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00002000u;
  id_ = value;
  // @@protoc_insertion_point(field_set:PBDNSMessage.id)
}

// optional .PBDNSMessage.DNSQuestion question = 12;
inline bool PBDNSMessage::has_question() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void PBDNSMessage::clear_question() {
  if (question_ != nullptr) question_->Clear();
  _has_bits_[0] &= ~0x00000100u;
}
inline const ::PBDNSMessage_DNSQuestion& PBDNSMessage::question() const {
  const ::PBDNSMessage_DNSQuestion* p = question_;
  // @@protoc_insertion_point(field_get:PBDNSMessage.question)
  return p != nullptr ? *p : *reinterpret_cast<const ::PBDNSMessage_DNSQuestion*>(
      &::_PBDNSMessage_DNSQuestion_default_instance_);
}
inline ::PBDNSMessage_DNSQuestion* PBDNSMessage::release_question() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.question)
  _has_bits_[0] &= ~0x00000100u;
  ::PBDNSMessage_DNSQuestion* temp = question_;
  question_ = nullptr;
  return temp;
}
inline ::PBDNSMessage_DNSQuestion* PBDNSMessage::mutable_question() {
  _has_bits_[0] |= 0x00000100u;
  if (question_ == nullptr) {
    auto* p = CreateMaybeMessage<::PBDNSMessage_DNSQuestion>(GetArenaNoVirtual());
    question_ = p;
  }
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.question)
  return question_;
}
inline void PBDNSMessage::set_allocated_question(::PBDNSMessage_DNSQuestion* question) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete question_;
  }
  if (question) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      question = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, question, submessage_arena);
    }
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  question_ = question;
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.question)
}

// optional .PBDNSMessage.DNSResponse response = 13;
inline bool PBDNSMessage::has_response() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void PBDNSMessage::clear_response() {
  if (response_ != nullptr) response_->Clear();
  _has_bits_[0] &= ~0x00000200u;
}
inline const ::PBDNSMessage_DNSResponse& PBDNSMessage::response() const {
  const ::PBDNSMessage_DNSResponse* p = response_;
  // @@protoc_insertion_point(field_get:PBDNSMessage.response)
  return p != nullptr ? *p : *reinterpret_cast<const ::PBDNSMessage_DNSResponse*>(
      &::_PBDNSMessage_DNSResponse_default_instance_);
}
inline ::PBDNSMessage_DNSResponse* PBDNSMessage::release_response() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.response)
  _has_bits_[0] &= ~0x00000200u;
  ::PBDNSMessage_DNSResponse* temp = response_;
  response_ = nullptr;
  return temp;
}
inline ::PBDNSMessage_DNSResponse* PBDNSMessage::mutable_response() {
  _has_bits_[0] |= 0x00000200u;
  if (response_ == nullptr) {
    auto* p = CreateMaybeMessage<::PBDNSMessage_DNSResponse>(GetArenaNoVirtual());
    response_ = p;
  }
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.response)
  return response_;
}
inline void PBDNSMessage::set_allocated_response(::PBDNSMessage_DNSResponse* response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete response_;
  }
  if (response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, response, submessage_arena);
    }
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  response_ = response;
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.response)
}

// optional bytes originalRequestorSubnet = 14;
inline bool PBDNSMessage::has_originalrequestorsubnet() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PBDNSMessage::clear_originalrequestorsubnet() {
  originalrequestorsubnet_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& PBDNSMessage::originalrequestorsubnet() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.originalRequestorSubnet)
  return originalrequestorsubnet_.GetNoArena();
}
inline void PBDNSMessage::set_originalrequestorsubnet(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  originalrequestorsubnet_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.originalRequestorSubnet)
}
inline void PBDNSMessage::set_originalrequestorsubnet(std::string&& value) {
  _has_bits_[0] |= 0x00000010u;
  originalrequestorsubnet_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.originalRequestorSubnet)
}
inline void PBDNSMessage::set_originalrequestorsubnet(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000010u;
  originalrequestorsubnet_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.originalRequestorSubnet)
}
inline void PBDNSMessage::set_originalrequestorsubnet(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000010u;
  originalrequestorsubnet_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.originalRequestorSubnet)
}
inline std::string* PBDNSMessage::mutable_originalrequestorsubnet() {
  _has_bits_[0] |= 0x00000010u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.originalRequestorSubnet)
  return originalrequestorsubnet_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage::release_originalrequestorsubnet() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.originalRequestorSubnet)
  if (!has_originalrequestorsubnet()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  return originalrequestorsubnet_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage::set_allocated_originalrequestorsubnet(std::string* originalrequestorsubnet) {
  if (originalrequestorsubnet != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  originalrequestorsubnet_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), originalrequestorsubnet);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.originalRequestorSubnet)
}

// optional string requestorId = 15;
inline bool PBDNSMessage::has_requestorid() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void PBDNSMessage::clear_requestorid() {
  requestorid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000020u;
}
inline const std::string& PBDNSMessage::requestorid() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.requestorId)
  return requestorid_.GetNoArena();
}
inline void PBDNSMessage::set_requestorid(const std::string& value) {
  _has_bits_[0] |= 0x00000020u;
  requestorid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.requestorId)
}
inline void PBDNSMessage::set_requestorid(std::string&& value) {
  _has_bits_[0] |= 0x00000020u;
  requestorid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.requestorId)
}
inline void PBDNSMessage::set_requestorid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000020u;
  requestorid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.requestorId)
}
inline void PBDNSMessage::set_requestorid(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000020u;
  requestorid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.requestorId)
}
inline std::string* PBDNSMessage::mutable_requestorid() {
  _has_bits_[0] |= 0x00000020u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.requestorId)
  return requestorid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage::release_requestorid() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.requestorId)
  if (!has_requestorid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000020u;
  return requestorid_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage::set_allocated_requestorid(std::string* requestorid) {
  if (requestorid != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  requestorid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), requestorid);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.requestorId)
}

// optional bytes initialRequestId = 16;
inline bool PBDNSMessage::has_initialrequestid() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void PBDNSMessage::clear_initialrequestid() {
  initialrequestid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000040u;
}
inline const std::string& PBDNSMessage::initialrequestid() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.initialRequestId)
  return initialrequestid_.GetNoArena();
}
inline void PBDNSMessage::set_initialrequestid(const std::string& value) {
  _has_bits_[0] |= 0x00000040u;
  initialrequestid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.initialRequestId)
}
inline void PBDNSMessage::set_initialrequestid(std::string&& value) {
  _has_bits_[0] |= 0x00000040u;
  initialrequestid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.initialRequestId)
}
inline void PBDNSMessage::set_initialrequestid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000040u;
  initialrequestid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.initialRequestId)
}
inline void PBDNSMessage::set_initialrequestid(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000040u;
  initialrequestid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.initialRequestId)
}
inline std::string* PBDNSMessage::mutable_initialrequestid() {
  _has_bits_[0] |= 0x00000040u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.initialRequestId)
  return initialrequestid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage::release_initialrequestid() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.initialRequestId)
  if (!has_initialrequestid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000040u;
  return initialrequestid_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage::set_allocated_initialrequestid(std::string* initialrequestid) {
  if (initialrequestid != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  initialrequestid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), initialrequestid);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.initialRequestId)
}

// optional bytes deviceId = 17;
inline bool PBDNSMessage::has_deviceid() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void PBDNSMessage::clear_deviceid() {
  deviceid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000080u;
}
inline const std::string& PBDNSMessage::deviceid() const {
  // @@protoc_insertion_point(field_get:PBDNSMessage.deviceId)
  return deviceid_.GetNoArena();
}
inline void PBDNSMessage::set_deviceid(const std::string& value) {
  _has_bits_[0] |= 0x00000080u;
  deviceid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PBDNSMessage.deviceId)
}
inline void PBDNSMessage::set_deviceid(std::string&& value) {
  _has_bits_[0] |= 0x00000080u;
  deviceid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PBDNSMessage.deviceId)
}
inline void PBDNSMessage::set_deviceid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000080u;
  deviceid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PBDNSMessage.deviceId)
}
inline void PBDNSMessage::set_deviceid(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000080u;
  deviceid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PBDNSMessage.deviceId)
}
inline std::string* PBDNSMessage::mutable_deviceid() {
  _has_bits_[0] |= 0x00000080u;
  // @@protoc_insertion_point(field_mutable:PBDNSMessage.deviceId)
  return deviceid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PBDNSMessage::release_deviceid() {
  // @@protoc_insertion_point(field_release:PBDNSMessage.deviceId)
  if (!has_deviceid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000080u;
  return deviceid_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PBDNSMessage::set_allocated_deviceid(std::string* deviceid) {
  if (deviceid != nullptr) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  deviceid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid);
  // @@protoc_insertion_point(field_set_allocated:PBDNSMessage.deviceId)
}

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::PBDNSMessage_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::PBDNSMessage_Type>() {
  return ::PBDNSMessage_Type_descriptor();
}
template <> struct is_proto_enum< ::PBDNSMessage_SocketFamily> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::PBDNSMessage_SocketFamily>() {
  return ::PBDNSMessage_SocketFamily_descriptor();
}
template <> struct is_proto_enum< ::PBDNSMessage_SocketProtocol> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::PBDNSMessage_SocketProtocol>() {
  return ::PBDNSMessage_SocketProtocol_descriptor();
}
template <> struct is_proto_enum< ::PBDNSMessage_PolicyType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::PBDNSMessage_PolicyType>() {
  return ::PBDNSMessage_PolicyType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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