// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: envoy/api/v2/core/base.proto

#ifndef PROTOBUF_INCLUDED_envoy_2fapi_2fv2_2fcore_2fbase_2eproto
#define PROTOBUF_INCLUDED_envoy_2fapi_2fv2_2fcore_2fbase_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3007000
#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 3007001 < 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/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/struct.pb.h>
#include <google/protobuf/wrappers.pb.h>
#include "validate/validate.pb.h"
#include "gogoproto/gogo.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_envoy_2fapi_2fv2_2fcore_2fbase_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto {
  static const ::google::protobuf::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::ParseTable schema[10]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors_envoy_2fapi_2fv2_2fcore_2fbase_2eproto();
namespace envoy {
namespace api {
namespace v2 {
namespace core {
class DataSource;
class DataSourceDefaultTypeInternal;
extern DataSourceDefaultTypeInternal _DataSource_default_instance_;
class HeaderValue;
class HeaderValueDefaultTypeInternal;
extern HeaderValueDefaultTypeInternal _HeaderValue_default_instance_;
class HeaderValueOption;
class HeaderValueOptionDefaultTypeInternal;
extern HeaderValueOptionDefaultTypeInternal _HeaderValueOption_default_instance_;
class Locality;
class LocalityDefaultTypeInternal;
extern LocalityDefaultTypeInternal _Locality_default_instance_;
class Metadata;
class MetadataDefaultTypeInternal;
extern MetadataDefaultTypeInternal _Metadata_default_instance_;
class Metadata_FilterMetadataEntry_DoNotUse;
class Metadata_FilterMetadataEntry_DoNotUseDefaultTypeInternal;
extern Metadata_FilterMetadataEntry_DoNotUseDefaultTypeInternal _Metadata_FilterMetadataEntry_DoNotUse_default_instance_;
class Node;
class NodeDefaultTypeInternal;
extern NodeDefaultTypeInternal _Node_default_instance_;
class RuntimeUInt32;
class RuntimeUInt32DefaultTypeInternal;
extern RuntimeUInt32DefaultTypeInternal _RuntimeUInt32_default_instance_;
class SocketOption;
class SocketOptionDefaultTypeInternal;
extern SocketOptionDefaultTypeInternal _SocketOption_default_instance_;
class TransportSocket;
class TransportSocketDefaultTypeInternal;
extern TransportSocketDefaultTypeInternal _TransportSocket_default_instance_;
}  // namespace core
}  // namespace v2
}  // namespace api
}  // namespace envoy
namespace google {
namespace protobuf {
template<> ::envoy::api::v2::core::DataSource* Arena::CreateMaybeMessage<::envoy::api::v2::core::DataSource>(Arena*);
template<> ::envoy::api::v2::core::HeaderValue* Arena::CreateMaybeMessage<::envoy::api::v2::core::HeaderValue>(Arena*);
template<> ::envoy::api::v2::core::HeaderValueOption* Arena::CreateMaybeMessage<::envoy::api::v2::core::HeaderValueOption>(Arena*);
template<> ::envoy::api::v2::core::Locality* Arena::CreateMaybeMessage<::envoy::api::v2::core::Locality>(Arena*);
template<> ::envoy::api::v2::core::Metadata* Arena::CreateMaybeMessage<::envoy::api::v2::core::Metadata>(Arena*);
template<> ::envoy::api::v2::core::Metadata_FilterMetadataEntry_DoNotUse* Arena::CreateMaybeMessage<::envoy::api::v2::core::Metadata_FilterMetadataEntry_DoNotUse>(Arena*);
template<> ::envoy::api::v2::core::Node* Arena::CreateMaybeMessage<::envoy::api::v2::core::Node>(Arena*);
template<> ::envoy::api::v2::core::RuntimeUInt32* Arena::CreateMaybeMessage<::envoy::api::v2::core::RuntimeUInt32>(Arena*);
template<> ::envoy::api::v2::core::SocketOption* Arena::CreateMaybeMessage<::envoy::api::v2::core::SocketOption>(Arena*);
template<> ::envoy::api::v2::core::TransportSocket* Arena::CreateMaybeMessage<::envoy::api::v2::core::TransportSocket>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace envoy {
namespace api {
namespace v2 {
namespace core {

enum SocketOption_SocketState {
  SocketOption_SocketState_STATE_PREBIND = 0,
  SocketOption_SocketState_STATE_BOUND = 1,
  SocketOption_SocketState_STATE_LISTENING = 2,
  SocketOption_SocketState_SocketOption_SocketState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
  SocketOption_SocketState_SocketOption_SocketState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
};
bool SocketOption_SocketState_IsValid(int value);
const SocketOption_SocketState SocketOption_SocketState_SocketState_MIN = SocketOption_SocketState_STATE_PREBIND;
const SocketOption_SocketState SocketOption_SocketState_SocketState_MAX = SocketOption_SocketState_STATE_LISTENING;
const int SocketOption_SocketState_SocketState_ARRAYSIZE = SocketOption_SocketState_SocketState_MAX + 1;

const ::google::protobuf::EnumDescriptor* SocketOption_SocketState_descriptor();
inline const ::std::string& SocketOption_SocketState_Name(SocketOption_SocketState value) {
  return ::google::protobuf::internal::NameOfEnum(
    SocketOption_SocketState_descriptor(), value);
}
inline bool SocketOption_SocketState_Parse(
    const ::std::string& name, SocketOption_SocketState* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SocketOption_SocketState>(
    SocketOption_SocketState_descriptor(), name, value);
}
enum RoutingPriority {
  DEFAULT = 0,
  HIGH = 1,
  RoutingPriority_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
  RoutingPriority_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
};
bool RoutingPriority_IsValid(int value);
const RoutingPriority RoutingPriority_MIN = DEFAULT;
const RoutingPriority RoutingPriority_MAX = HIGH;
const int RoutingPriority_ARRAYSIZE = RoutingPriority_MAX + 1;

const ::google::protobuf::EnumDescriptor* RoutingPriority_descriptor();
inline const ::std::string& RoutingPriority_Name(RoutingPriority value) {
  return ::google::protobuf::internal::NameOfEnum(
    RoutingPriority_descriptor(), value);
}
inline bool RoutingPriority_Parse(
    const ::std::string& name, RoutingPriority* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RoutingPriority>(
    RoutingPriority_descriptor(), name, value);
}
enum RequestMethod {
  METHOD_UNSPECIFIED = 0,
  GET = 1,
  HEAD = 2,
  POST = 3,
  PUT = 4,
  DELETE = 5,
  CONNECT = 6,
  OPTIONS = 7,
  TRACE = 8,
  RequestMethod_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
  RequestMethod_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
};
bool RequestMethod_IsValid(int value);
const RequestMethod RequestMethod_MIN = METHOD_UNSPECIFIED;
const RequestMethod RequestMethod_MAX = TRACE;
const int RequestMethod_ARRAYSIZE = RequestMethod_MAX + 1;

const ::google::protobuf::EnumDescriptor* RequestMethod_descriptor();
inline const ::std::string& RequestMethod_Name(RequestMethod value) {
  return ::google::protobuf::internal::NameOfEnum(
    RequestMethod_descriptor(), value);
}
inline bool RequestMethod_Parse(
    const ::std::string& name, RequestMethod* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RequestMethod>(
    RequestMethod_descriptor(), name, value);
}
// ===================================================================

class Locality :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.Locality) */ {
 public:
  Locality();
  virtual ~Locality();

  Locality(const Locality& from);

  inline Locality& operator=(const Locality& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Locality(Locality&& from) noexcept
    : Locality() {
    *this = ::std::move(from);
  }

  inline Locality& operator=(Locality&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const Locality& default_instance();

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Locality* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string region = 1;
  void clear_region();
  static const int kRegionFieldNumber = 1;
  const ::std::string& region() const;
  void set_region(const ::std::string& value);
  #if LANG_CXX11
  void set_region(::std::string&& value);
  #endif
  void set_region(const char* value);
  void set_region(const char* value, size_t size);
  ::std::string* mutable_region();
  ::std::string* release_region();
  void set_allocated_region(::std::string* region);

  // string zone = 2;
  void clear_zone();
  static const int kZoneFieldNumber = 2;
  const ::std::string& zone() const;
  void set_zone(const ::std::string& value);
  #if LANG_CXX11
  void set_zone(::std::string&& value);
  #endif
  void set_zone(const char* value);
  void set_zone(const char* value, size_t size);
  ::std::string* mutable_zone();
  ::std::string* release_zone();
  void set_allocated_zone(::std::string* zone);

  // string sub_zone = 3;
  void clear_sub_zone();
  static const int kSubZoneFieldNumber = 3;
  const ::std::string& sub_zone() const;
  void set_sub_zone(const ::std::string& value);
  #if LANG_CXX11
  void set_sub_zone(::std::string&& value);
  #endif
  void set_sub_zone(const char* value);
  void set_sub_zone(const char* value, size_t size);
  ::std::string* mutable_sub_zone();
  ::std::string* release_sub_zone();
  void set_allocated_sub_zone(::std::string* sub_zone);

  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.Locality)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr region_;
  ::google::protobuf::internal::ArenaStringPtr zone_;
  ::google::protobuf::internal::ArenaStringPtr sub_zone_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// -------------------------------------------------------------------

class Node :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.Node) */ {
 public:
  Node();
  virtual ~Node();

  Node(const Node& from);

  inline Node& operator=(const Node& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Node(Node&& from) noexcept
    : Node() {
    *this = ::std::move(from);
  }

  inline Node& operator=(Node&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const Node& default_instance();

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Node* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string id = 1;
  void clear_id();
  static const int kIdFieldNumber = 1;
  const ::std::string& id() const;
  void set_id(const ::std::string& value);
  #if LANG_CXX11
  void set_id(::std::string&& value);
  #endif
  void set_id(const char* value);
  void set_id(const char* value, size_t size);
  ::std::string* mutable_id();
  ::std::string* release_id();
  void set_allocated_id(::std::string* id);

  // string cluster = 2;
  void clear_cluster();
  static const int kClusterFieldNumber = 2;
  const ::std::string& cluster() const;
  void set_cluster(const ::std::string& value);
  #if LANG_CXX11
  void set_cluster(::std::string&& value);
  #endif
  void set_cluster(const char* value);
  void set_cluster(const char* value, size_t size);
  ::std::string* mutable_cluster();
  ::std::string* release_cluster();
  void set_allocated_cluster(::std::string* cluster);

  // string build_version = 5;
  void clear_build_version();
  static const int kBuildVersionFieldNumber = 5;
  const ::std::string& build_version() const;
  void set_build_version(const ::std::string& value);
  #if LANG_CXX11
  void set_build_version(::std::string&& value);
  #endif
  void set_build_version(const char* value);
  void set_build_version(const char* value, size_t size);
  ::std::string* mutable_build_version();
  ::std::string* release_build_version();
  void set_allocated_build_version(::std::string* build_version);

  // .google.protobuf.Struct metadata = 3;
  bool has_metadata() const;
  void clear_metadata();
  static const int kMetadataFieldNumber = 3;
  const ::google::protobuf::Struct& metadata() const;
  ::google::protobuf::Struct* release_metadata();
  ::google::protobuf::Struct* mutable_metadata();
  void set_allocated_metadata(::google::protobuf::Struct* metadata);

  // .envoy.api.v2.core.Locality locality = 4;
  bool has_locality() const;
  void clear_locality();
  static const int kLocalityFieldNumber = 4;
  const ::envoy::api::v2::core::Locality& locality() const;
  ::envoy::api::v2::core::Locality* release_locality();
  ::envoy::api::v2::core::Locality* mutable_locality();
  void set_allocated_locality(::envoy::api::v2::core::Locality* locality);

  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.Node)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr id_;
  ::google::protobuf::internal::ArenaStringPtr cluster_;
  ::google::protobuf::internal::ArenaStringPtr build_version_;
  ::google::protobuf::Struct* metadata_;
  ::envoy::api::v2::core::Locality* locality_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// -------------------------------------------------------------------

class Metadata_FilterMetadataEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<Metadata_FilterMetadataEntry_DoNotUse, 
    ::std::string, ::google::protobuf::Struct,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE,
    0 > {
public:
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
static bool _ParseMap(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  typedef ::google::protobuf::internal::MapEntry<Metadata_FilterMetadataEntry_DoNotUse, 
    ::std::string, ::google::protobuf::Struct,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE,
    0 > SuperType;
  Metadata_FilterMetadataEntry_DoNotUse();
  Metadata_FilterMetadataEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const Metadata_FilterMetadataEntry_DoNotUse& other);
  static const Metadata_FilterMetadataEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Metadata_FilterMetadataEntry_DoNotUse*>(&_Metadata_FilterMetadataEntry_DoNotUse_default_instance_); }
  void MergeFrom(const ::google::protobuf::Message& other) final;
  ::google::protobuf::Metadata GetMetadata() const;
};

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

class Metadata :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.Metadata) */ {
 public:
  Metadata();
  virtual ~Metadata();

  Metadata(const Metadata& from);

  inline Metadata& operator=(const Metadata& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Metadata(Metadata&& from) noexcept
    : Metadata() {
    *this = ::std::move(from);
  }

  inline Metadata& operator=(Metadata&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const Metadata& default_instance();

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Metadata* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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


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

  // map<string, .google.protobuf.Struct> filter_metadata = 1;
  int filter_metadata_size() const;
  void clear_filter_metadata();
  static const int kFilterMetadataFieldNumber = 1;
  const ::google::protobuf::Map< ::std::string, ::google::protobuf::Struct >&
      filter_metadata() const;
  ::google::protobuf::Map< ::std::string, ::google::protobuf::Struct >*
      mutable_filter_metadata();

  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.Metadata)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::MapField<
      Metadata_FilterMetadataEntry_DoNotUse,
      ::std::string, ::google::protobuf::Struct,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE,
      0 > filter_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// -------------------------------------------------------------------

class RuntimeUInt32 :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.RuntimeUInt32) */ {
 public:
  RuntimeUInt32();
  virtual ~RuntimeUInt32();

  RuntimeUInt32(const RuntimeUInt32& from);

  inline RuntimeUInt32& operator=(const RuntimeUInt32& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RuntimeUInt32(RuntimeUInt32&& from) noexcept
    : RuntimeUInt32() {
    *this = ::std::move(from);
  }

  inline RuntimeUInt32& operator=(RuntimeUInt32&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const RuntimeUInt32& default_instance();

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RuntimeUInt32* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string runtime_key = 3 [(.validate.rules) = {
  void clear_runtime_key();
  static const int kRuntimeKeyFieldNumber = 3;
  const ::std::string& runtime_key() const;
  void set_runtime_key(const ::std::string& value);
  #if LANG_CXX11
  void set_runtime_key(::std::string&& value);
  #endif
  void set_runtime_key(const char* value);
  void set_runtime_key(const char* value, size_t size);
  ::std::string* mutable_runtime_key();
  ::std::string* release_runtime_key();
  void set_allocated_runtime_key(::std::string* runtime_key);

  // uint32 default_value = 2;
  void clear_default_value();
  static const int kDefaultValueFieldNumber = 2;
  ::google::protobuf::uint32 default_value() const;
  void set_default_value(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.RuntimeUInt32)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr runtime_key_;
  ::google::protobuf::uint32 default_value_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// -------------------------------------------------------------------

class HeaderValue :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.HeaderValue) */ {
 public:
  HeaderValue();
  virtual ~HeaderValue();

  HeaderValue(const HeaderValue& from);

  inline HeaderValue& operator=(const HeaderValue& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  HeaderValue(HeaderValue&& from) noexcept
    : HeaderValue() {
    *this = ::std::move(from);
  }

  inline HeaderValue& operator=(HeaderValue&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const HeaderValue& default_instance();

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HeaderValue* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string key = 1;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  #if LANG_CXX11
  void set_key(::std::string&& value);
  #endif
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // string value = 2;
  void clear_value();
  static const int kValueFieldNumber = 2;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  #if LANG_CXX11
  void set_value(::std::string&& value);
  #endif
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.HeaderValue)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// -------------------------------------------------------------------

class HeaderValueOption :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.HeaderValueOption) */ {
 public:
  HeaderValueOption();
  virtual ~HeaderValueOption();

  HeaderValueOption(const HeaderValueOption& from);

  inline HeaderValueOption& operator=(const HeaderValueOption& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  HeaderValueOption(HeaderValueOption&& from) noexcept
    : HeaderValueOption() {
    *this = ::std::move(from);
  }

  inline HeaderValueOption& operator=(HeaderValueOption&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const HeaderValueOption& default_instance();

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HeaderValueOption* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // .envoy.api.v2.core.HeaderValue header = 1;
  bool has_header() const;
  void clear_header();
  static const int kHeaderFieldNumber = 1;
  const ::envoy::api::v2::core::HeaderValue& header() const;
  ::envoy::api::v2::core::HeaderValue* release_header();
  ::envoy::api::v2::core::HeaderValue* mutable_header();
  void set_allocated_header(::envoy::api::v2::core::HeaderValue* header);

  // .google.protobuf.BoolValue append = 2;
  bool has_append() const;
  void clear_append();
  static const int kAppendFieldNumber = 2;
  const ::google::protobuf::BoolValue& append() const;
  ::google::protobuf::BoolValue* release_append();
  ::google::protobuf::BoolValue* mutable_append();
  void set_allocated_append(::google::protobuf::BoolValue* append);

  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.HeaderValueOption)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::envoy::api::v2::core::HeaderValue* header_;
  ::google::protobuf::BoolValue* append_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// -------------------------------------------------------------------

class DataSource :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.DataSource) */ {
 public:
  DataSource();
  virtual ~DataSource();

  DataSource(const DataSource& from);

  inline DataSource& operator=(const DataSource& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  DataSource(DataSource&& from) noexcept
    : DataSource() {
    *this = ::std::move(from);
  }

  inline DataSource& operator=(DataSource&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const DataSource& default_instance();

  enum SpecifierCase {
    kFilename = 1,
    kInlineBytes = 2,
    kInlineString = 3,
    SPECIFIER_NOT_SET = 0,
  };

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DataSource* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string filename = 1 [(.validate.rules) = {
  private:
  bool has_filename() const;
  public:
  void clear_filename();
  static const int kFilenameFieldNumber = 1;
  const ::std::string& filename() const;
  void set_filename(const ::std::string& value);
  #if LANG_CXX11
  void set_filename(::std::string&& value);
  #endif
  void set_filename(const char* value);
  void set_filename(const char* value, size_t size);
  ::std::string* mutable_filename();
  ::std::string* release_filename();
  void set_allocated_filename(::std::string* filename);

  // bytes inline_bytes = 2 [(.validate.rules) = {
  private:
  bool has_inline_bytes() const;
  public:
  void clear_inline_bytes();
  static const int kInlineBytesFieldNumber = 2;
  const ::std::string& inline_bytes() const;
  void set_inline_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_inline_bytes(::std::string&& value);
  #endif
  void set_inline_bytes(const char* value);
  void set_inline_bytes(const void* value, size_t size);
  ::std::string* mutable_inline_bytes();
  ::std::string* release_inline_bytes();
  void set_allocated_inline_bytes(::std::string* inline_bytes);

  // string inline_string = 3 [(.validate.rules) = {
  private:
  bool has_inline_string() const;
  public:
  void clear_inline_string();
  static const int kInlineStringFieldNumber = 3;
  const ::std::string& inline_string() const;
  void set_inline_string(const ::std::string& value);
  #if LANG_CXX11
  void set_inline_string(::std::string&& value);
  #endif
  void set_inline_string(const char* value);
  void set_inline_string(const char* value, size_t size);
  ::std::string* mutable_inline_string();
  ::std::string* release_inline_string();
  void set_allocated_inline_string(::std::string* inline_string);

  void clear_specifier();
  SpecifierCase specifier_case() const;
  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.DataSource)
 private:
  class HasBitSetters;
  void set_has_filename();
  void set_has_inline_bytes();
  void set_has_inline_string();

  inline bool has_specifier() const;
  inline void clear_has_specifier();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  union SpecifierUnion {
    SpecifierUnion() {}
    ::google::protobuf::internal::ArenaStringPtr filename_;
    ::google::protobuf::internal::ArenaStringPtr inline_bytes_;
    ::google::protobuf::internal::ArenaStringPtr inline_string_;
  } specifier_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// -------------------------------------------------------------------

class TransportSocket :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.TransportSocket) */ {
 public:
  TransportSocket();
  virtual ~TransportSocket();

  TransportSocket(const TransportSocket& from);

  inline TransportSocket& operator=(const TransportSocket& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TransportSocket(TransportSocket&& from) noexcept
    : TransportSocket() {
    *this = ::std::move(from);
  }

  inline TransportSocket& operator=(TransportSocket&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const TransportSocket& default_instance();

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TransportSocket* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string name = 1 [(.validate.rules) = {
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  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);

  // .google.protobuf.Struct config = 2;
  bool has_config() const;
  void clear_config();
  static const int kConfigFieldNumber = 2;
  const ::google::protobuf::Struct& config() const;
  ::google::protobuf::Struct* release_config();
  ::google::protobuf::Struct* mutable_config();
  void set_allocated_config(::google::protobuf::Struct* config);

  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.TransportSocket)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::Struct* config_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// -------------------------------------------------------------------

class SocketOption :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:envoy.api.v2.core.SocketOption) */ {
 public:
  SocketOption();
  virtual ~SocketOption();

  SocketOption(const SocketOption& from);

  inline SocketOption& operator=(const SocketOption& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SocketOption(SocketOption&& from) noexcept
    : SocketOption() {
    *this = ::std::move(from);
  }

  inline SocketOption& operator=(SocketOption&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const SocketOption& default_instance();

  enum ValueCase {
    kIntValue = 4,
    kBufValue = 5,
    VALUE_NOT_SET = 0,
  };

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

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

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

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

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SocketOption* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

  typedef SocketOption_SocketState SocketState;
  static const SocketState STATE_PREBIND =
    SocketOption_SocketState_STATE_PREBIND;
  static const SocketState STATE_BOUND =
    SocketOption_SocketState_STATE_BOUND;
  static const SocketState STATE_LISTENING =
    SocketOption_SocketState_STATE_LISTENING;
  static inline bool SocketState_IsValid(int value) {
    return SocketOption_SocketState_IsValid(value);
  }
  static const SocketState SocketState_MIN =
    SocketOption_SocketState_SocketState_MIN;
  static const SocketState SocketState_MAX =
    SocketOption_SocketState_SocketState_MAX;
  static const int SocketState_ARRAYSIZE =
    SocketOption_SocketState_SocketState_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  SocketState_descriptor() {
    return SocketOption_SocketState_descriptor();
  }
  static inline const ::std::string& SocketState_Name(SocketState value) {
    return SocketOption_SocketState_Name(value);
  }
  static inline bool SocketState_Parse(const ::std::string& name,
      SocketState* value) {
    return SocketOption_SocketState_Parse(name, value);
  }

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

  // string description = 1;
  void clear_description();
  static const int kDescriptionFieldNumber = 1;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  ::std::string* mutable_description();
  ::std::string* release_description();
  void set_allocated_description(::std::string* description);

  // int64 level = 2;
  void clear_level();
  static const int kLevelFieldNumber = 2;
  ::google::protobuf::int64 level() const;
  void set_level(::google::protobuf::int64 value);

  // int64 name = 3;
  void clear_name();
  static const int kNameFieldNumber = 3;
  ::google::protobuf::int64 name() const;
  void set_name(::google::protobuf::int64 value);

  // .envoy.api.v2.core.SocketOption.SocketState state = 6 [(.validate.rules) = {
  void clear_state();
  static const int kStateFieldNumber = 6;
  ::envoy::api::v2::core::SocketOption_SocketState state() const;
  void set_state(::envoy::api::v2::core::SocketOption_SocketState value);

  // int64 int_value = 4;
  private:
  bool has_int_value() const;
  public:
  void clear_int_value();
  static const int kIntValueFieldNumber = 4;
  ::google::protobuf::int64 int_value() const;
  void set_int_value(::google::protobuf::int64 value);

  // bytes buf_value = 5;
  private:
  bool has_buf_value() const;
  public:
  void clear_buf_value();
  static const int kBufValueFieldNumber = 5;
  const ::std::string& buf_value() const;
  void set_buf_value(const ::std::string& value);
  #if LANG_CXX11
  void set_buf_value(::std::string&& value);
  #endif
  void set_buf_value(const char* value);
  void set_buf_value(const void* value, size_t size);
  ::std::string* mutable_buf_value();
  ::std::string* release_buf_value();
  void set_allocated_buf_value(::std::string* buf_value);

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:envoy.api.v2.core.SocketOption)
 private:
  class HasBitSetters;
  void set_has_int_value();
  void set_has_buf_value();

  inline bool has_value() const;
  inline void clear_has_value();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  ::google::protobuf::int64 level_;
  ::google::protobuf::int64 name_;
  int state_;
  union ValueUnion {
    ValueUnion() {}
    ::google::protobuf::int64 int_value_;
    ::google::protobuf::internal::ArenaStringPtr buf_value_;
  } value_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::TableStruct_envoy_2fapi_2fv2_2fcore_2fbase_2eproto;
};
// ===================================================================


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

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

// string region = 1;
inline void Locality::clear_region() {
  region_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Locality::region() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.Locality.region)
  return region_.GetNoArena();
}
inline void Locality::set_region(const ::std::string& value) {
  
  region_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.Locality.region)
}
#if LANG_CXX11
inline void Locality::set_region(::std::string&& value) {
  
  region_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.Locality.region)
}
#endif
inline void Locality::set_region(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  region_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.Locality.region)
}
inline void Locality::set_region(const char* value, size_t size) {
  
  region_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.Locality.region)
}
inline ::std::string* Locality::mutable_region() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.Locality.region)
  return region_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Locality::release_region() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.Locality.region)
  
  return region_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Locality::set_allocated_region(::std::string* region) {
  if (region != nullptr) {
    
  } else {
    
  }
  region_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), region);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.Locality.region)
}

// string zone = 2;
inline void Locality::clear_zone() {
  zone_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Locality::zone() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.Locality.zone)
  return zone_.GetNoArena();
}
inline void Locality::set_zone(const ::std::string& value) {
  
  zone_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.Locality.zone)
}
#if LANG_CXX11
inline void Locality::set_zone(::std::string&& value) {
  
  zone_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.Locality.zone)
}
#endif
inline void Locality::set_zone(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  zone_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.Locality.zone)
}
inline void Locality::set_zone(const char* value, size_t size) {
  
  zone_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.Locality.zone)
}
inline ::std::string* Locality::mutable_zone() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.Locality.zone)
  return zone_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Locality::release_zone() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.Locality.zone)
  
  return zone_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Locality::set_allocated_zone(::std::string* zone) {
  if (zone != nullptr) {
    
  } else {
    
  }
  zone_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), zone);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.Locality.zone)
}

// string sub_zone = 3;
inline void Locality::clear_sub_zone() {
  sub_zone_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Locality::sub_zone() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.Locality.sub_zone)
  return sub_zone_.GetNoArena();
}
inline void Locality::set_sub_zone(const ::std::string& value) {
  
  sub_zone_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.Locality.sub_zone)
}
#if LANG_CXX11
inline void Locality::set_sub_zone(::std::string&& value) {
  
  sub_zone_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.Locality.sub_zone)
}
#endif
inline void Locality::set_sub_zone(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  sub_zone_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.Locality.sub_zone)
}
inline void Locality::set_sub_zone(const char* value, size_t size) {
  
  sub_zone_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.Locality.sub_zone)
}
inline ::std::string* Locality::mutable_sub_zone() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.Locality.sub_zone)
  return sub_zone_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Locality::release_sub_zone() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.Locality.sub_zone)
  
  return sub_zone_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Locality::set_allocated_sub_zone(::std::string* sub_zone) {
  if (sub_zone != nullptr) {
    
  } else {
    
  }
  sub_zone_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), sub_zone);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.Locality.sub_zone)
}

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

// Node

// string id = 1;
inline void Node::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Node::id() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.Node.id)
  return id_.GetNoArena();
}
inline void Node::set_id(const ::std::string& value) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.Node.id)
}
#if LANG_CXX11
inline void Node::set_id(::std::string&& value) {
  
  id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.Node.id)
}
#endif
inline void Node::set_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.Node.id)
}
inline void Node::set_id(const char* value, size_t size) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.Node.id)
}
inline ::std::string* Node::mutable_id() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.Node.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Node::release_id() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.Node.id)
  
  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Node::set_allocated_id(::std::string* id) {
  if (id != nullptr) {
    
  } else {
    
  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.Node.id)
}

// string cluster = 2;
inline void Node::clear_cluster() {
  cluster_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Node::cluster() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.Node.cluster)
  return cluster_.GetNoArena();
}
inline void Node::set_cluster(const ::std::string& value) {
  
  cluster_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.Node.cluster)
}
#if LANG_CXX11
inline void Node::set_cluster(::std::string&& value) {
  
  cluster_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.Node.cluster)
}
#endif
inline void Node::set_cluster(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cluster_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.Node.cluster)
}
inline void Node::set_cluster(const char* value, size_t size) {
  
  cluster_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.Node.cluster)
}
inline ::std::string* Node::mutable_cluster() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.Node.cluster)
  return cluster_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Node::release_cluster() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.Node.cluster)
  
  return cluster_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Node::set_allocated_cluster(::std::string* cluster) {
  if (cluster != nullptr) {
    
  } else {
    
  }
  cluster_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), cluster);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.Node.cluster)
}

// .google.protobuf.Struct metadata = 3;
inline bool Node::has_metadata() const {
  return this != internal_default_instance() && metadata_ != nullptr;
}
inline const ::google::protobuf::Struct& Node::metadata() const {
  const ::google::protobuf::Struct* p = metadata_;
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.Node.metadata)
  return p != nullptr ? *p : *reinterpret_cast<const ::google::protobuf::Struct*>(
      &::google::protobuf::_Struct_default_instance_);
}
inline ::google::protobuf::Struct* Node::release_metadata() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.Node.metadata)
  
  ::google::protobuf::Struct* temp = metadata_;
  metadata_ = nullptr;
  return temp;
}
inline ::google::protobuf::Struct* Node::mutable_metadata() {
  
  if (metadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::protobuf::Struct>(GetArenaNoVirtual());
    metadata_ = p;
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.Node.metadata)
  return metadata_;
}
inline void Node::set_allocated_metadata(::google::protobuf::Struct* metadata) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(metadata_);
  }
  if (metadata) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(metadata)->GetArena();
    if (message_arena != submessage_arena) {
      metadata = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, metadata, submessage_arena);
    }
    
  } else {
    
  }
  metadata_ = metadata;
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.Node.metadata)
}

// .envoy.api.v2.core.Locality locality = 4;
inline bool Node::has_locality() const {
  return this != internal_default_instance() && locality_ != nullptr;
}
inline void Node::clear_locality() {
  if (GetArenaNoVirtual() == nullptr && locality_ != nullptr) {
    delete locality_;
  }
  locality_ = nullptr;
}
inline const ::envoy::api::v2::core::Locality& Node::locality() const {
  const ::envoy::api::v2::core::Locality* p = locality_;
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.Node.locality)
  return p != nullptr ? *p : *reinterpret_cast<const ::envoy::api::v2::core::Locality*>(
      &::envoy::api::v2::core::_Locality_default_instance_);
}
inline ::envoy::api::v2::core::Locality* Node::release_locality() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.Node.locality)
  
  ::envoy::api::v2::core::Locality* temp = locality_;
  locality_ = nullptr;
  return temp;
}
inline ::envoy::api::v2::core::Locality* Node::mutable_locality() {
  
  if (locality_ == nullptr) {
    auto* p = CreateMaybeMessage<::envoy::api::v2::core::Locality>(GetArenaNoVirtual());
    locality_ = p;
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.Node.locality)
  return locality_;
}
inline void Node::set_allocated_locality(::envoy::api::v2::core::Locality* locality) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete locality_;
  }
  if (locality) {
    ::google::protobuf::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      locality = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, locality, submessage_arena);
    }
    
  } else {
    
  }
  locality_ = locality;
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.Node.locality)
}

// string build_version = 5;
inline void Node::clear_build_version() {
  build_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Node::build_version() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.Node.build_version)
  return build_version_.GetNoArena();
}
inline void Node::set_build_version(const ::std::string& value) {
  
  build_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.Node.build_version)
}
#if LANG_CXX11
inline void Node::set_build_version(::std::string&& value) {
  
  build_version_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.Node.build_version)
}
#endif
inline void Node::set_build_version(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  build_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.Node.build_version)
}
inline void Node::set_build_version(const char* value, size_t size) {
  
  build_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.Node.build_version)
}
inline ::std::string* Node::mutable_build_version() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.Node.build_version)
  return build_version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Node::release_build_version() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.Node.build_version)
  
  return build_version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Node::set_allocated_build_version(::std::string* build_version) {
  if (build_version != nullptr) {
    
  } else {
    
  }
  build_version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), build_version);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.Node.build_version)
}

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

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

// Metadata

// map<string, .google.protobuf.Struct> filter_metadata = 1;
inline int Metadata::filter_metadata_size() const {
  return filter_metadata_.size();
}
inline const ::google::protobuf::Map< ::std::string, ::google::protobuf::Struct >&
Metadata::filter_metadata() const {
  // @@protoc_insertion_point(field_map:envoy.api.v2.core.Metadata.filter_metadata)
  return filter_metadata_.GetMap();
}
inline ::google::protobuf::Map< ::std::string, ::google::protobuf::Struct >*
Metadata::mutable_filter_metadata() {
  // @@protoc_insertion_point(field_mutable_map:envoy.api.v2.core.Metadata.filter_metadata)
  return filter_metadata_.MutableMap();
}

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

// RuntimeUInt32

// uint32 default_value = 2;
inline void RuntimeUInt32::clear_default_value() {
  default_value_ = 0u;
}
inline ::google::protobuf::uint32 RuntimeUInt32::default_value() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.RuntimeUInt32.default_value)
  return default_value_;
}
inline void RuntimeUInt32::set_default_value(::google::protobuf::uint32 value) {
  
  default_value_ = value;
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.RuntimeUInt32.default_value)
}

// string runtime_key = 3 [(.validate.rules) = {
inline void RuntimeUInt32::clear_runtime_key() {
  runtime_key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RuntimeUInt32::runtime_key() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.RuntimeUInt32.runtime_key)
  return runtime_key_.GetNoArena();
}
inline void RuntimeUInt32::set_runtime_key(const ::std::string& value) {
  
  runtime_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.RuntimeUInt32.runtime_key)
}
#if LANG_CXX11
inline void RuntimeUInt32::set_runtime_key(::std::string&& value) {
  
  runtime_key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.RuntimeUInt32.runtime_key)
}
#endif
inline void RuntimeUInt32::set_runtime_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  runtime_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.RuntimeUInt32.runtime_key)
}
inline void RuntimeUInt32::set_runtime_key(const char* value, size_t size) {
  
  runtime_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.RuntimeUInt32.runtime_key)
}
inline ::std::string* RuntimeUInt32::mutable_runtime_key() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.RuntimeUInt32.runtime_key)
  return runtime_key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RuntimeUInt32::release_runtime_key() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.RuntimeUInt32.runtime_key)
  
  return runtime_key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RuntimeUInt32::set_allocated_runtime_key(::std::string* runtime_key) {
  if (runtime_key != nullptr) {
    
  } else {
    
  }
  runtime_key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), runtime_key);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.RuntimeUInt32.runtime_key)
}

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

// HeaderValue

// string key = 1;
inline void HeaderValue::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& HeaderValue::key() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.HeaderValue.key)
  return key_.GetNoArena();
}
inline void HeaderValue::set_key(const ::std::string& value) {
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.HeaderValue.key)
}
#if LANG_CXX11
inline void HeaderValue::set_key(::std::string&& value) {
  
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.HeaderValue.key)
}
#endif
inline void HeaderValue::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.HeaderValue.key)
}
inline void HeaderValue::set_key(const char* value, size_t size) {
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.HeaderValue.key)
}
inline ::std::string* HeaderValue::mutable_key() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.HeaderValue.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HeaderValue::release_key() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.HeaderValue.key)
  
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HeaderValue::set_allocated_key(::std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.HeaderValue.key)
}

// string value = 2;
inline void HeaderValue::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& HeaderValue::value() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.HeaderValue.value)
  return value_.GetNoArena();
}
inline void HeaderValue::set_value(const ::std::string& value) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.HeaderValue.value)
}
#if LANG_CXX11
inline void HeaderValue::set_value(::std::string&& value) {
  
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.HeaderValue.value)
}
#endif
inline void HeaderValue::set_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.HeaderValue.value)
}
inline void HeaderValue::set_value(const char* value, size_t size) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.HeaderValue.value)
}
inline ::std::string* HeaderValue::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.HeaderValue.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HeaderValue::release_value() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.HeaderValue.value)
  
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HeaderValue::set_allocated_value(::std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.HeaderValue.value)
}

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

// HeaderValueOption

// .envoy.api.v2.core.HeaderValue header = 1;
inline bool HeaderValueOption::has_header() const {
  return this != internal_default_instance() && header_ != nullptr;
}
inline void HeaderValueOption::clear_header() {
  if (GetArenaNoVirtual() == nullptr && header_ != nullptr) {
    delete header_;
  }
  header_ = nullptr;
}
inline const ::envoy::api::v2::core::HeaderValue& HeaderValueOption::header() const {
  const ::envoy::api::v2::core::HeaderValue* p = header_;
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.HeaderValueOption.header)
  return p != nullptr ? *p : *reinterpret_cast<const ::envoy::api::v2::core::HeaderValue*>(
      &::envoy::api::v2::core::_HeaderValue_default_instance_);
}
inline ::envoy::api::v2::core::HeaderValue* HeaderValueOption::release_header() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.HeaderValueOption.header)
  
  ::envoy::api::v2::core::HeaderValue* temp = header_;
  header_ = nullptr;
  return temp;
}
inline ::envoy::api::v2::core::HeaderValue* HeaderValueOption::mutable_header() {
  
  if (header_ == nullptr) {
    auto* p = CreateMaybeMessage<::envoy::api::v2::core::HeaderValue>(GetArenaNoVirtual());
    header_ = p;
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.HeaderValueOption.header)
  return header_;
}
inline void HeaderValueOption::set_allocated_header(::envoy::api::v2::core::HeaderValue* header) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete header_;
  }
  if (header) {
    ::google::protobuf::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      header = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    
  } else {
    
  }
  header_ = header;
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.HeaderValueOption.header)
}

// .google.protobuf.BoolValue append = 2;
inline bool HeaderValueOption::has_append() const {
  return this != internal_default_instance() && append_ != nullptr;
}
inline const ::google::protobuf::BoolValue& HeaderValueOption::append() const {
  const ::google::protobuf::BoolValue* p = append_;
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.HeaderValueOption.append)
  return p != nullptr ? *p : *reinterpret_cast<const ::google::protobuf::BoolValue*>(
      &::google::protobuf::_BoolValue_default_instance_);
}
inline ::google::protobuf::BoolValue* HeaderValueOption::release_append() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.HeaderValueOption.append)
  
  ::google::protobuf::BoolValue* temp = append_;
  append_ = nullptr;
  return temp;
}
inline ::google::protobuf::BoolValue* HeaderValueOption::mutable_append() {
  
  if (append_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::protobuf::BoolValue>(GetArenaNoVirtual());
    append_ = p;
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.HeaderValueOption.append)
  return append_;
}
inline void HeaderValueOption::set_allocated_append(::google::protobuf::BoolValue* append) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(append_);
  }
  if (append) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(append)->GetArena();
    if (message_arena != submessage_arena) {
      append = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, append, submessage_arena);
    }
    
  } else {
    
  }
  append_ = append;
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.HeaderValueOption.append)
}

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

// DataSource

// string filename = 1 [(.validate.rules) = {
inline bool DataSource::has_filename() const {
  return specifier_case() == kFilename;
}
inline void DataSource::set_has_filename() {
  _oneof_case_[0] = kFilename;
}
inline void DataSource::clear_filename() {
  if (has_filename()) {
    specifier_.filename_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_specifier();
  }
}
inline const ::std::string& DataSource::filename() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.DataSource.filename)
  if (has_filename()) {
    return specifier_.filename_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void DataSource::set_filename(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.filename)
  if (!has_filename()) {
    clear_specifier();
    set_has_filename();
    specifier_.filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.filename)
}
#if LANG_CXX11
inline void DataSource::set_filename(::std::string&& value) {
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.filename)
  if (!has_filename()) {
    clear_specifier();
    set_has_filename();
    specifier_.filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.DataSource.filename)
}
#endif
inline void DataSource::set_filename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  if (!has_filename()) {
    clear_specifier();
    set_has_filename();
    specifier_.filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.DataSource.filename)
}
inline void DataSource::set_filename(const char* value, size_t size) {
  if (!has_filename()) {
    clear_specifier();
    set_has_filename();
    specifier_.filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.DataSource.filename)
}
inline ::std::string* DataSource::mutable_filename() {
  if (!has_filename()) {
    clear_specifier();
    set_has_filename();
    specifier_.filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.DataSource.filename)
  return specifier_.filename_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataSource::release_filename() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.DataSource.filename)
  if (has_filename()) {
    clear_has_specifier();
    return specifier_.filename_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return nullptr;
  }
}
inline void DataSource::set_allocated_filename(::std::string* filename) {
  if (has_specifier()) {
    clear_specifier();
  }
  if (filename != nullptr) {
    set_has_filename();
    specifier_.filename_.UnsafeSetDefault(filename);
  }
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.DataSource.filename)
}

// bytes inline_bytes = 2 [(.validate.rules) = {
inline bool DataSource::has_inline_bytes() const {
  return specifier_case() == kInlineBytes;
}
inline void DataSource::set_has_inline_bytes() {
  _oneof_case_[0] = kInlineBytes;
}
inline void DataSource::clear_inline_bytes() {
  if (has_inline_bytes()) {
    specifier_.inline_bytes_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_specifier();
  }
}
inline const ::std::string& DataSource::inline_bytes() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.DataSource.inline_bytes)
  if (has_inline_bytes()) {
    return specifier_.inline_bytes_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void DataSource::set_inline_bytes(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.inline_bytes)
  if (!has_inline_bytes()) {
    clear_specifier();
    set_has_inline_bytes();
    specifier_.inline_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.inline_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.inline_bytes)
}
#if LANG_CXX11
inline void DataSource::set_inline_bytes(::std::string&& value) {
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.inline_bytes)
  if (!has_inline_bytes()) {
    clear_specifier();
    set_has_inline_bytes();
    specifier_.inline_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.inline_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.DataSource.inline_bytes)
}
#endif
inline void DataSource::set_inline_bytes(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  if (!has_inline_bytes()) {
    clear_specifier();
    set_has_inline_bytes();
    specifier_.inline_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.inline_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.DataSource.inline_bytes)
}
inline void DataSource::set_inline_bytes(const void* value, size_t size) {
  if (!has_inline_bytes()) {
    clear_specifier();
    set_has_inline_bytes();
    specifier_.inline_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.inline_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.DataSource.inline_bytes)
}
inline ::std::string* DataSource::mutable_inline_bytes() {
  if (!has_inline_bytes()) {
    clear_specifier();
    set_has_inline_bytes();
    specifier_.inline_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.DataSource.inline_bytes)
  return specifier_.inline_bytes_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataSource::release_inline_bytes() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.DataSource.inline_bytes)
  if (has_inline_bytes()) {
    clear_has_specifier();
    return specifier_.inline_bytes_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return nullptr;
  }
}
inline void DataSource::set_allocated_inline_bytes(::std::string* inline_bytes) {
  if (has_specifier()) {
    clear_specifier();
  }
  if (inline_bytes != nullptr) {
    set_has_inline_bytes();
    specifier_.inline_bytes_.UnsafeSetDefault(inline_bytes);
  }
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.DataSource.inline_bytes)
}

// string inline_string = 3 [(.validate.rules) = {
inline bool DataSource::has_inline_string() const {
  return specifier_case() == kInlineString;
}
inline void DataSource::set_has_inline_string() {
  _oneof_case_[0] = kInlineString;
}
inline void DataSource::clear_inline_string() {
  if (has_inline_string()) {
    specifier_.inline_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_specifier();
  }
}
inline const ::std::string& DataSource::inline_string() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.DataSource.inline_string)
  if (has_inline_string()) {
    return specifier_.inline_string_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void DataSource::set_inline_string(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.inline_string)
  if (!has_inline_string()) {
    clear_specifier();
    set_has_inline_string();
    specifier_.inline_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.inline_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.inline_string)
}
#if LANG_CXX11
inline void DataSource::set_inline_string(::std::string&& value) {
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.DataSource.inline_string)
  if (!has_inline_string()) {
    clear_specifier();
    set_has_inline_string();
    specifier_.inline_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.inline_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.DataSource.inline_string)
}
#endif
inline void DataSource::set_inline_string(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  if (!has_inline_string()) {
    clear_specifier();
    set_has_inline_string();
    specifier_.inline_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.inline_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.DataSource.inline_string)
}
inline void DataSource::set_inline_string(const char* value, size_t size) {
  if (!has_inline_string()) {
    clear_specifier();
    set_has_inline_string();
    specifier_.inline_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  specifier_.inline_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.DataSource.inline_string)
}
inline ::std::string* DataSource::mutable_inline_string() {
  if (!has_inline_string()) {
    clear_specifier();
    set_has_inline_string();
    specifier_.inline_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.DataSource.inline_string)
  return specifier_.inline_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataSource::release_inline_string() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.DataSource.inline_string)
  if (has_inline_string()) {
    clear_has_specifier();
    return specifier_.inline_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return nullptr;
  }
}
inline void DataSource::set_allocated_inline_string(::std::string* inline_string) {
  if (has_specifier()) {
    clear_specifier();
  }
  if (inline_string != nullptr) {
    set_has_inline_string();
    specifier_.inline_string_.UnsafeSetDefault(inline_string);
  }
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.DataSource.inline_string)
}

inline bool DataSource::has_specifier() const {
  return specifier_case() != SPECIFIER_NOT_SET;
}
inline void DataSource::clear_has_specifier() {
  _oneof_case_[0] = SPECIFIER_NOT_SET;
}
inline DataSource::SpecifierCase DataSource::specifier_case() const {
  return DataSource::SpecifierCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TransportSocket

// string name = 1 [(.validate.rules) = {
inline void TransportSocket::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& TransportSocket::name() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.TransportSocket.name)
  return name_.GetNoArena();
}
inline void TransportSocket::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.TransportSocket.name)
}
#if LANG_CXX11
inline void TransportSocket::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.TransportSocket.name)
}
#endif
inline void TransportSocket::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.TransportSocket.name)
}
inline void TransportSocket::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.TransportSocket.name)
}
inline ::std::string* TransportSocket::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.TransportSocket.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TransportSocket::release_name() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.TransportSocket.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TransportSocket::set_allocated_name(::std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.TransportSocket.name)
}

// .google.protobuf.Struct config = 2;
inline bool TransportSocket::has_config() const {
  return this != internal_default_instance() && config_ != nullptr;
}
inline const ::google::protobuf::Struct& TransportSocket::config() const {
  const ::google::protobuf::Struct* p = config_;
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.TransportSocket.config)
  return p != nullptr ? *p : *reinterpret_cast<const ::google::protobuf::Struct*>(
      &::google::protobuf::_Struct_default_instance_);
}
inline ::google::protobuf::Struct* TransportSocket::release_config() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.TransportSocket.config)
  
  ::google::protobuf::Struct* temp = config_;
  config_ = nullptr;
  return temp;
}
inline ::google::protobuf::Struct* TransportSocket::mutable_config() {
  
  if (config_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::protobuf::Struct>(GetArenaNoVirtual());
    config_ = p;
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.TransportSocket.config)
  return config_;
}
inline void TransportSocket::set_allocated_config(::google::protobuf::Struct* config) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(config_);
  }
  if (config) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(config)->GetArena();
    if (message_arena != submessage_arena) {
      config = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, config, submessage_arena);
    }
    
  } else {
    
  }
  config_ = config;
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.TransportSocket.config)
}

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

// SocketOption

// string description = 1;
inline void SocketOption::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& SocketOption::description() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.SocketOption.description)
  return description_.GetNoArena();
}
inline void SocketOption::set_description(const ::std::string& value) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.SocketOption.description)
}
#if LANG_CXX11
inline void SocketOption::set_description(::std::string&& value) {
  
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.SocketOption.description)
}
#endif
inline void SocketOption::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.SocketOption.description)
}
inline void SocketOption::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.SocketOption.description)
}
inline ::std::string* SocketOption::mutable_description() {
  
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.SocketOption.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SocketOption::release_description() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.SocketOption.description)
  
  return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SocketOption::set_allocated_description(::std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.SocketOption.description)
}

// int64 level = 2;
inline void SocketOption::clear_level() {
  level_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 SocketOption::level() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.SocketOption.level)
  return level_;
}
inline void SocketOption::set_level(::google::protobuf::int64 value) {
  
  level_ = value;
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.SocketOption.level)
}

// int64 name = 3;
inline void SocketOption::clear_name() {
  name_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 SocketOption::name() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.SocketOption.name)
  return name_;
}
inline void SocketOption::set_name(::google::protobuf::int64 value) {
  
  name_ = value;
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.SocketOption.name)
}

// int64 int_value = 4;
inline bool SocketOption::has_int_value() const {
  return value_case() == kIntValue;
}
inline void SocketOption::set_has_int_value() {
  _oneof_case_[0] = kIntValue;
}
inline void SocketOption::clear_int_value() {
  if (has_int_value()) {
    value_.int_value_ = PROTOBUF_LONGLONG(0);
    clear_has_value();
  }
}
inline ::google::protobuf::int64 SocketOption::int_value() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.SocketOption.int_value)
  if (has_int_value()) {
    return value_.int_value_;
  }
  return PROTOBUF_LONGLONG(0);
}
inline void SocketOption::set_int_value(::google::protobuf::int64 value) {
  if (!has_int_value()) {
    clear_value();
    set_has_int_value();
  }
  value_.int_value_ = value;
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.SocketOption.int_value)
}

// bytes buf_value = 5;
inline bool SocketOption::has_buf_value() const {
  return value_case() == kBufValue;
}
inline void SocketOption::set_has_buf_value() {
  _oneof_case_[0] = kBufValue;
}
inline void SocketOption::clear_buf_value() {
  if (has_buf_value()) {
    value_.buf_value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_value();
  }
}
inline const ::std::string& SocketOption::buf_value() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.SocketOption.buf_value)
  if (has_buf_value()) {
    return value_.buf_value_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void SocketOption::set_buf_value(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.SocketOption.buf_value)
  if (!has_buf_value()) {
    clear_value();
    set_has_buf_value();
    value_.buf_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  value_.buf_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.SocketOption.buf_value)
}
#if LANG_CXX11
inline void SocketOption::set_buf_value(::std::string&& value) {
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.SocketOption.buf_value)
  if (!has_buf_value()) {
    clear_value();
    set_has_buf_value();
    value_.buf_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  value_.buf_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:envoy.api.v2.core.SocketOption.buf_value)
}
#endif
inline void SocketOption::set_buf_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  if (!has_buf_value()) {
    clear_value();
    set_has_buf_value();
    value_.buf_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  value_.buf_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:envoy.api.v2.core.SocketOption.buf_value)
}
inline void SocketOption::set_buf_value(const void* value, size_t size) {
  if (!has_buf_value()) {
    clear_value();
    set_has_buf_value();
    value_.buf_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  value_.buf_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:envoy.api.v2.core.SocketOption.buf_value)
}
inline ::std::string* SocketOption::mutable_buf_value() {
  if (!has_buf_value()) {
    clear_value();
    set_has_buf_value();
    value_.buf_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:envoy.api.v2.core.SocketOption.buf_value)
  return value_.buf_value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SocketOption::release_buf_value() {
  // @@protoc_insertion_point(field_release:envoy.api.v2.core.SocketOption.buf_value)
  if (has_buf_value()) {
    clear_has_value();
    return value_.buf_value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return nullptr;
  }
}
inline void SocketOption::set_allocated_buf_value(::std::string* buf_value) {
  if (has_value()) {
    clear_value();
  }
  if (buf_value != nullptr) {
    set_has_buf_value();
    value_.buf_value_.UnsafeSetDefault(buf_value);
  }
  // @@protoc_insertion_point(field_set_allocated:envoy.api.v2.core.SocketOption.buf_value)
}

// .envoy.api.v2.core.SocketOption.SocketState state = 6 [(.validate.rules) = {
inline void SocketOption::clear_state() {
  state_ = 0;
}
inline ::envoy::api::v2::core::SocketOption_SocketState SocketOption::state() const {
  // @@protoc_insertion_point(field_get:envoy.api.v2.core.SocketOption.state)
  return static_cast< ::envoy::api::v2::core::SocketOption_SocketState >(state_);
}
inline void SocketOption::set_state(::envoy::api::v2::core::SocketOption_SocketState value) {
  
  state_ = value;
  // @@protoc_insertion_point(field_set:envoy.api.v2.core.SocketOption.state)
}

inline bool SocketOption::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void SocketOption::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline SocketOption::ValueCase SocketOption::value_case() const {
  return SocketOption::ValueCase(_oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace core
}  // namespace v2
}  // namespace api
}  // namespace envoy

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::envoy::api::v2::core::SocketOption_SocketState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::envoy::api::v2::core::SocketOption_SocketState>() {
  return ::envoy::api::v2::core::SocketOption_SocketState_descriptor();
}
template <> struct is_proto_enum< ::envoy::api::v2::core::RoutingPriority> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::envoy::api::v2::core::RoutingPriority>() {
  return ::envoy::api::v2::core::RoutingPriority_descriptor();
}
template <> struct is_proto_enum< ::envoy::api::v2::core::RequestMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::envoy::api::v2::core::RequestMethod>() {
  return ::envoy::api::v2::core::RequestMethod_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

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