// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: prometheus/remote/types.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_prometheus_2fremote_2ftypes_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_prometheus_2fremote_2ftypes_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_prometheus_2fremote_2ftypes_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_prometheus_2fremote_2ftypes_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_prometheus_2fremote_2ftypes_2eproto;
namespace prometheus {
class Chunk;
struct ChunkDefaultTypeInternal;
extern ChunkDefaultTypeInternal _Chunk_default_instance_;
class ChunkedSeries;
struct ChunkedSeriesDefaultTypeInternal;
extern ChunkedSeriesDefaultTypeInternal _ChunkedSeries_default_instance_;
class Exemplar;
struct ExemplarDefaultTypeInternal;
extern ExemplarDefaultTypeInternal _Exemplar_default_instance_;
class Label;
struct LabelDefaultTypeInternal;
extern LabelDefaultTypeInternal _Label_default_instance_;
class LabelMatcher;
struct LabelMatcherDefaultTypeInternal;
extern LabelMatcherDefaultTypeInternal _LabelMatcher_default_instance_;
class Labels;
struct LabelsDefaultTypeInternal;
extern LabelsDefaultTypeInternal _Labels_default_instance_;
class MetricMetadata;
struct MetricMetadataDefaultTypeInternal;
extern MetricMetadataDefaultTypeInternal _MetricMetadata_default_instance_;
class ReadHints;
struct ReadHintsDefaultTypeInternal;
extern ReadHintsDefaultTypeInternal _ReadHints_default_instance_;
class Sample;
struct SampleDefaultTypeInternal;
extern SampleDefaultTypeInternal _Sample_default_instance_;
class TimeSeries;
struct TimeSeriesDefaultTypeInternal;
extern TimeSeriesDefaultTypeInternal _TimeSeries_default_instance_;
}  // namespace prometheus
PROTOBUF_NAMESPACE_OPEN
template<> ::prometheus::Chunk* Arena::CreateMaybeMessage<::prometheus::Chunk>(Arena*);
template<> ::prometheus::ChunkedSeries* Arena::CreateMaybeMessage<::prometheus::ChunkedSeries>(Arena*);
template<> ::prometheus::Exemplar* Arena::CreateMaybeMessage<::prometheus::Exemplar>(Arena*);
template<> ::prometheus::Label* Arena::CreateMaybeMessage<::prometheus::Label>(Arena*);
template<> ::prometheus::LabelMatcher* Arena::CreateMaybeMessage<::prometheus::LabelMatcher>(Arena*);
template<> ::prometheus::Labels* Arena::CreateMaybeMessage<::prometheus::Labels>(Arena*);
template<> ::prometheus::MetricMetadata* Arena::CreateMaybeMessage<::prometheus::MetricMetadata>(Arena*);
template<> ::prometheus::ReadHints* Arena::CreateMaybeMessage<::prometheus::ReadHints>(Arena*);
template<> ::prometheus::Sample* Arena::CreateMaybeMessage<::prometheus::Sample>(Arena*);
template<> ::prometheus::TimeSeries* Arena::CreateMaybeMessage<::prometheus::TimeSeries>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace prometheus {

enum MetricMetadata_MetricType : int {
  MetricMetadata_MetricType_UNKNOWN = 0,
  MetricMetadata_MetricType_COUNTER = 1,
  MetricMetadata_MetricType_GAUGE = 2,
  MetricMetadata_MetricType_HISTOGRAM = 3,
  MetricMetadata_MetricType_GAUGEHISTOGRAM = 4,
  MetricMetadata_MetricType_SUMMARY = 5,
  MetricMetadata_MetricType_INFO = 6,
  MetricMetadata_MetricType_STATESET = 7,
  MetricMetadata_MetricType_MetricMetadata_MetricType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  MetricMetadata_MetricType_MetricMetadata_MetricType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool MetricMetadata_MetricType_IsValid(int value);
constexpr MetricMetadata_MetricType MetricMetadata_MetricType_MetricType_MIN = MetricMetadata_MetricType_UNKNOWN;
constexpr MetricMetadata_MetricType MetricMetadata_MetricType_MetricType_MAX = MetricMetadata_MetricType_STATESET;
constexpr int MetricMetadata_MetricType_MetricType_ARRAYSIZE = MetricMetadata_MetricType_MetricType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MetricMetadata_MetricType_descriptor();
template<typename T>
inline const std::string& MetricMetadata_MetricType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MetricMetadata_MetricType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MetricMetadata_MetricType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MetricMetadata_MetricType_descriptor(), enum_t_value);
}
inline bool MetricMetadata_MetricType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MetricMetadata_MetricType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MetricMetadata_MetricType>(
    MetricMetadata_MetricType_descriptor(), name, value);
}
enum LabelMatcher_Type : int {
  LabelMatcher_Type_EQ = 0,
  LabelMatcher_Type_NEQ = 1,
  LabelMatcher_Type_RE = 2,
  LabelMatcher_Type_NRE = 3,
  LabelMatcher_Type_LabelMatcher_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  LabelMatcher_Type_LabelMatcher_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool LabelMatcher_Type_IsValid(int value);
constexpr LabelMatcher_Type LabelMatcher_Type_Type_MIN = LabelMatcher_Type_EQ;
constexpr LabelMatcher_Type LabelMatcher_Type_Type_MAX = LabelMatcher_Type_NRE;
constexpr int LabelMatcher_Type_Type_ARRAYSIZE = LabelMatcher_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LabelMatcher_Type_descriptor();
template<typename T>
inline const std::string& LabelMatcher_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LabelMatcher_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LabelMatcher_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LabelMatcher_Type_descriptor(), enum_t_value);
}
inline bool LabelMatcher_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LabelMatcher_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LabelMatcher_Type>(
    LabelMatcher_Type_descriptor(), name, value);
}
enum Chunk_Encoding : int {
  Chunk_Encoding_UNKNOWN = 0,
  Chunk_Encoding_XOR = 1,
  Chunk_Encoding_Chunk_Encoding_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  Chunk_Encoding_Chunk_Encoding_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool Chunk_Encoding_IsValid(int value);
constexpr Chunk_Encoding Chunk_Encoding_Encoding_MIN = Chunk_Encoding_UNKNOWN;
constexpr Chunk_Encoding Chunk_Encoding_Encoding_MAX = Chunk_Encoding_XOR;
constexpr int Chunk_Encoding_Encoding_ARRAYSIZE = Chunk_Encoding_Encoding_MAX + 1;

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

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

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

  inline MetricMetadata& operator=(const MetricMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline MetricMetadata& operator=(MetricMetadata&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MetricMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetricMetadata* internal_default_instance() {
    return reinterpret_cast<const MetricMetadata*>(
               &_MetricMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(MetricMetadata& a, MetricMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(MetricMetadata* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetricMetadata* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MetricMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MetricMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MetricMetadata& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MetricMetadata& from) {
    MetricMetadata::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MetricMetadata* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.MetricMetadata";
  }
  protected:
  explicit MetricMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef MetricMetadata_MetricType MetricType;
  static constexpr MetricType UNKNOWN =
    MetricMetadata_MetricType_UNKNOWN;
  static constexpr MetricType COUNTER =
    MetricMetadata_MetricType_COUNTER;
  static constexpr MetricType GAUGE =
    MetricMetadata_MetricType_GAUGE;
  static constexpr MetricType HISTOGRAM =
    MetricMetadata_MetricType_HISTOGRAM;
  static constexpr MetricType GAUGEHISTOGRAM =
    MetricMetadata_MetricType_GAUGEHISTOGRAM;
  static constexpr MetricType SUMMARY =
    MetricMetadata_MetricType_SUMMARY;
  static constexpr MetricType INFO =
    MetricMetadata_MetricType_INFO;
  static constexpr MetricType STATESET =
    MetricMetadata_MetricType_STATESET;
  static inline bool MetricType_IsValid(int value) {
    return MetricMetadata_MetricType_IsValid(value);
  }
  static constexpr MetricType MetricType_MIN =
    MetricMetadata_MetricType_MetricType_MIN;
  static constexpr MetricType MetricType_MAX =
    MetricMetadata_MetricType_MetricType_MAX;
  static constexpr int MetricType_ARRAYSIZE =
    MetricMetadata_MetricType_MetricType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MetricType_descriptor() {
    return MetricMetadata_MetricType_descriptor();
  }
  template<typename T>
  static inline const std::string& MetricType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MetricType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MetricType_Name.");
    return MetricMetadata_MetricType_Name(enum_t_value);
  }
  static inline bool MetricType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MetricType* value) {
    return MetricMetadata_MetricType_Parse(name, value);
  }

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

  enum : int {
    kMetricFamilyNameFieldNumber = 2,
    kHelpFieldNumber = 4,
    kUnitFieldNumber = 5,
    kTypeFieldNumber = 1,
  };
  // string metric_family_name = 2;
  void clear_metric_family_name();
  const std::string& metric_family_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_metric_family_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_metric_family_name();
  PROTOBUF_NODISCARD std::string* release_metric_family_name();
  void set_allocated_metric_family_name(std::string* metric_family_name);
  private:
  const std::string& _internal_metric_family_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_metric_family_name(const std::string& value);
  std::string* _internal_mutable_metric_family_name();
  public:

  // string help = 4;
  void clear_help();
  const std::string& help() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_help(ArgT0&& arg0, ArgT... args);
  std::string* mutable_help();
  PROTOBUF_NODISCARD std::string* release_help();
  void set_allocated_help(std::string* help);
  private:
  const std::string& _internal_help() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_help(const std::string& value);
  std::string* _internal_mutable_help();
  public:

  // string unit = 5;
  void clear_unit();
  const std::string& unit() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_unit(ArgT0&& arg0, ArgT... args);
  std::string* mutable_unit();
  PROTOBUF_NODISCARD std::string* release_unit();
  void set_allocated_unit(std::string* unit);
  private:
  const std::string& _internal_unit() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_unit(const std::string& value);
  std::string* _internal_mutable_unit();
  public:

  // .prometheus.MetricMetadata.MetricType type = 1;
  void clear_type();
  ::prometheus::MetricMetadata_MetricType type() const;
  void set_type(::prometheus::MetricMetadata_MetricType value);
  private:
  ::prometheus::MetricMetadata_MetricType _internal_type() const;
  void _internal_set_type(::prometheus::MetricMetadata_MetricType value);
  public:

  // @@protoc_insertion_point(class_scope:prometheus.MetricMetadata)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr metric_family_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr help_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unit_;
    int type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Sample& operator=(const Sample& from) {
    CopyFrom(from);
    return *this;
  }
  inline Sample& operator=(Sample&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Sample& default_instance() {
    return *internal_default_instance();
  }
  static inline const Sample* internal_default_instance() {
    return reinterpret_cast<const Sample*>(
               &_Sample_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Sample& a, Sample& b) {
    a.Swap(&b);
  }
  inline void Swap(Sample* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Sample* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Sample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Sample>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Sample& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Sample& from) {
    Sample::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Sample* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.Sample";
  }
  protected:
  explicit Sample(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
    kTimestampFieldNumber = 2,
  };
  // double value = 1;
  void clear_value();
  double value() const;
  void set_value(double value);
  private:
  double _internal_value() const;
  void _internal_set_value(double value);
  public:

  // int64 timestamp = 2;
  void clear_timestamp();
  int64_t timestamp() const;
  void set_timestamp(int64_t value);
  private:
  int64_t _internal_timestamp() const;
  void _internal_set_timestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:prometheus.Sample)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    double value_;
    int64_t timestamp_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Exemplar& operator=(const Exemplar& from) {
    CopyFrom(from);
    return *this;
  }
  inline Exemplar& operator=(Exemplar&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Exemplar& default_instance() {
    return *internal_default_instance();
  }
  static inline const Exemplar* internal_default_instance() {
    return reinterpret_cast<const Exemplar*>(
               &_Exemplar_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Exemplar& a, Exemplar& b) {
    a.Swap(&b);
  }
  inline void Swap(Exemplar* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Exemplar* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Exemplar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Exemplar>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Exemplar& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Exemplar& from) {
    Exemplar::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Exemplar* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.Exemplar";
  }
  protected:
  explicit Exemplar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLabelsFieldNumber = 1,
    kValueFieldNumber = 2,
    kTimestampFieldNumber = 3,
  };
  // repeated .prometheus.Label labels = 1;
  int labels_size() const;
  private:
  int _internal_labels_size() const;
  public:
  void clear_labels();
  ::prometheus::Label* mutable_labels(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >*
      mutable_labels();
  private:
  const ::prometheus::Label& _internal_labels(int index) const;
  ::prometheus::Label* _internal_add_labels();
  public:
  const ::prometheus::Label& labels(int index) const;
  ::prometheus::Label* add_labels();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >&
      labels() const;

  // double value = 2;
  void clear_value();
  double value() const;
  void set_value(double value);
  private:
  double _internal_value() const;
  void _internal_set_value(double value);
  public:

  // int64 timestamp = 3;
  void clear_timestamp();
  int64_t timestamp() const;
  void set_timestamp(int64_t value);
  private:
  int64_t _internal_timestamp() const;
  void _internal_set_timestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:prometheus.Exemplar)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label > labels_;
    double value_;
    int64_t timestamp_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline TimeSeries& operator=(const TimeSeries& from) {
    CopyFrom(from);
    return *this;
  }
  inline TimeSeries& operator=(TimeSeries&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TimeSeries& default_instance() {
    return *internal_default_instance();
  }
  static inline const TimeSeries* internal_default_instance() {
    return reinterpret_cast<const TimeSeries*>(
               &_TimeSeries_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(TimeSeries& a, TimeSeries& b) {
    a.Swap(&b);
  }
  inline void Swap(TimeSeries* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TimeSeries* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TimeSeries* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TimeSeries>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TimeSeries& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TimeSeries& from) {
    TimeSeries::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TimeSeries* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.TimeSeries";
  }
  protected:
  explicit TimeSeries(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLabelsFieldNumber = 1,
    kSamplesFieldNumber = 2,
    kExemplarsFieldNumber = 3,
  };
  // repeated .prometheus.Label labels = 1;
  int labels_size() const;
  private:
  int _internal_labels_size() const;
  public:
  void clear_labels();
  ::prometheus::Label* mutable_labels(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >*
      mutable_labels();
  private:
  const ::prometheus::Label& _internal_labels(int index) const;
  ::prometheus::Label* _internal_add_labels();
  public:
  const ::prometheus::Label& labels(int index) const;
  ::prometheus::Label* add_labels();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >&
      labels() const;

  // repeated .prometheus.Sample samples = 2;
  int samples_size() const;
  private:
  int _internal_samples_size() const;
  public:
  void clear_samples();
  ::prometheus::Sample* mutable_samples(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Sample >*
      mutable_samples();
  private:
  const ::prometheus::Sample& _internal_samples(int index) const;
  ::prometheus::Sample* _internal_add_samples();
  public:
  const ::prometheus::Sample& samples(int index) const;
  ::prometheus::Sample* add_samples();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Sample >&
      samples() const;

  // repeated .prometheus.Exemplar exemplars = 3;
  int exemplars_size() const;
  private:
  int _internal_exemplars_size() const;
  public:
  void clear_exemplars();
  ::prometheus::Exemplar* mutable_exemplars(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Exemplar >*
      mutable_exemplars();
  private:
  const ::prometheus::Exemplar& _internal_exemplars(int index) const;
  ::prometheus::Exemplar* _internal_add_exemplars();
  public:
  const ::prometheus::Exemplar& exemplars(int index) const;
  ::prometheus::Exemplar* add_exemplars();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Exemplar >&
      exemplars() const;

  // @@protoc_insertion_point(class_scope:prometheus.TimeSeries)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label > labels_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Sample > samples_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Exemplar > exemplars_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Label& operator=(const Label& from) {
    CopyFrom(from);
    return *this;
  }
  inline Label& operator=(Label&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Label& default_instance() {
    return *internal_default_instance();
  }
  static inline const Label* internal_default_instance() {
    return reinterpret_cast<const Label*>(
               &_Label_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Label& a, Label& b) {
    a.Swap(&b);
  }
  inline void Swap(Label* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Label* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Label* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Label>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Label& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Label& from) {
    Label::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Label* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.Label";
  }
  protected:
  explicit Label(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string value = 2;
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // @@protoc_insertion_point(class_scope:prometheus.Label)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Labels& operator=(const Labels& from) {
    CopyFrom(from);
    return *this;
  }
  inline Labels& operator=(Labels&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Labels& default_instance() {
    return *internal_default_instance();
  }
  static inline const Labels* internal_default_instance() {
    return reinterpret_cast<const Labels*>(
               &_Labels_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Labels& a, Labels& b) {
    a.Swap(&b);
  }
  inline void Swap(Labels* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Labels* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Labels* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Labels>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Labels& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Labels& from) {
    Labels::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Labels* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.Labels";
  }
  protected:
  explicit Labels(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLabelsFieldNumber = 1,
  };
  // repeated .prometheus.Label labels = 1;
  int labels_size() const;
  private:
  int _internal_labels_size() const;
  public:
  void clear_labels();
  ::prometheus::Label* mutable_labels(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >*
      mutable_labels();
  private:
  const ::prometheus::Label& _internal_labels(int index) const;
  ::prometheus::Label* _internal_add_labels();
  public:
  const ::prometheus::Label& labels(int index) const;
  ::prometheus::Label* add_labels();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >&
      labels() const;

  // @@protoc_insertion_point(class_scope:prometheus.Labels)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label > labels_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LabelMatcher& operator=(const LabelMatcher& from) {
    CopyFrom(from);
    return *this;
  }
  inline LabelMatcher& operator=(LabelMatcher&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LabelMatcher& default_instance() {
    return *internal_default_instance();
  }
  static inline const LabelMatcher* internal_default_instance() {
    return reinterpret_cast<const LabelMatcher*>(
               &_LabelMatcher_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(LabelMatcher& a, LabelMatcher& b) {
    a.Swap(&b);
  }
  inline void Swap(LabelMatcher* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LabelMatcher* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LabelMatcher* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LabelMatcher>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LabelMatcher& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LabelMatcher& from) {
    LabelMatcher::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LabelMatcher* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.LabelMatcher";
  }
  protected:
  explicit LabelMatcher(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef LabelMatcher_Type Type;
  static constexpr Type EQ =
    LabelMatcher_Type_EQ;
  static constexpr Type NEQ =
    LabelMatcher_Type_NEQ;
  static constexpr Type RE =
    LabelMatcher_Type_RE;
  static constexpr Type NRE =
    LabelMatcher_Type_NRE;
  static inline bool Type_IsValid(int value) {
    return LabelMatcher_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    LabelMatcher_Type_Type_MIN;
  static constexpr Type Type_MAX =
    LabelMatcher_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    LabelMatcher_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return LabelMatcher_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return LabelMatcher_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return LabelMatcher_Type_Parse(name, value);
  }

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

  enum : int {
    kNameFieldNumber = 2,
    kValueFieldNumber = 3,
    kTypeFieldNumber = 1,
  };
  // string name = 2;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string value = 3;
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // .prometheus.LabelMatcher.Type type = 1;
  void clear_type();
  ::prometheus::LabelMatcher_Type type() const;
  void set_type(::prometheus::LabelMatcher_Type value);
  private:
  ::prometheus::LabelMatcher_Type _internal_type() const;
  void _internal_set_type(::prometheus::LabelMatcher_Type value);
  public:

  // @@protoc_insertion_point(class_scope:prometheus.LabelMatcher)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    int type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ReadHints& operator=(const ReadHints& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReadHints& operator=(ReadHints&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReadHints& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReadHints* internal_default_instance() {
    return reinterpret_cast<const ReadHints*>(
               &_ReadHints_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(ReadHints& a, ReadHints& b) {
    a.Swap(&b);
  }
  inline void Swap(ReadHints* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReadHints* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ReadHints* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReadHints>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReadHints& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ReadHints& from) {
    ReadHints::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReadHints* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.ReadHints";
  }
  protected:
  explicit ReadHints(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kGroupingFieldNumber = 5,
    kFuncFieldNumber = 2,
    kStepMsFieldNumber = 1,
    kStartMsFieldNumber = 3,
    kEndMsFieldNumber = 4,
    kRangeMsFieldNumber = 7,
    kByFieldNumber = 6,
  };
  // repeated string grouping = 5;
  int grouping_size() const;
  private:
  int _internal_grouping_size() const;
  public:
  void clear_grouping();
  const std::string& grouping(int index) const;
  std::string* mutable_grouping(int index);
  void set_grouping(int index, const std::string& value);
  void set_grouping(int index, std::string&& value);
  void set_grouping(int index, const char* value);
  void set_grouping(int index, const char* value, size_t size);
  std::string* add_grouping();
  void add_grouping(const std::string& value);
  void add_grouping(std::string&& value);
  void add_grouping(const char* value);
  void add_grouping(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& grouping() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_grouping();
  private:
  const std::string& _internal_grouping(int index) const;
  std::string* _internal_add_grouping();
  public:

  // string func = 2;
  void clear_func();
  const std::string& func() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_func(ArgT0&& arg0, ArgT... args);
  std::string* mutable_func();
  PROTOBUF_NODISCARD std::string* release_func();
  void set_allocated_func(std::string* func);
  private:
  const std::string& _internal_func() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_func(const std::string& value);
  std::string* _internal_mutable_func();
  public:

  // int64 step_ms = 1;
  void clear_step_ms();
  int64_t step_ms() const;
  void set_step_ms(int64_t value);
  private:
  int64_t _internal_step_ms() const;
  void _internal_set_step_ms(int64_t value);
  public:

  // int64 start_ms = 3;
  void clear_start_ms();
  int64_t start_ms() const;
  void set_start_ms(int64_t value);
  private:
  int64_t _internal_start_ms() const;
  void _internal_set_start_ms(int64_t value);
  public:

  // int64 end_ms = 4;
  void clear_end_ms();
  int64_t end_ms() const;
  void set_end_ms(int64_t value);
  private:
  int64_t _internal_end_ms() const;
  void _internal_set_end_ms(int64_t value);
  public:

  // int64 range_ms = 7;
  void clear_range_ms();
  int64_t range_ms() const;
  void set_range_ms(int64_t value);
  private:
  int64_t _internal_range_ms() const;
  void _internal_set_range_ms(int64_t value);
  public:

  // bool by = 6;
  void clear_by();
  bool by() const;
  void set_by(bool value);
  private:
  bool _internal_by() const;
  void _internal_set_by(bool value);
  public:

  // @@protoc_insertion_point(class_scope:prometheus.ReadHints)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> grouping_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr func_;
    int64_t step_ms_;
    int64_t start_ms_;
    int64_t end_ms_;
    int64_t range_ms_;
    bool by_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Chunk& operator=(const Chunk& from) {
    CopyFrom(from);
    return *this;
  }
  inline Chunk& operator=(Chunk&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Chunk& default_instance() {
    return *internal_default_instance();
  }
  static inline const Chunk* internal_default_instance() {
    return reinterpret_cast<const Chunk*>(
               &_Chunk_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(Chunk& a, Chunk& b) {
    a.Swap(&b);
  }
  inline void Swap(Chunk* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Chunk* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Chunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Chunk>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Chunk& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Chunk& from) {
    Chunk::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Chunk* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.Chunk";
  }
  protected:
  explicit Chunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef Chunk_Encoding Encoding;
  static constexpr Encoding UNKNOWN =
    Chunk_Encoding_UNKNOWN;
  static constexpr Encoding XOR =
    Chunk_Encoding_XOR;
  static inline bool Encoding_IsValid(int value) {
    return Chunk_Encoding_IsValid(value);
  }
  static constexpr Encoding Encoding_MIN =
    Chunk_Encoding_Encoding_MIN;
  static constexpr Encoding Encoding_MAX =
    Chunk_Encoding_Encoding_MAX;
  static constexpr int Encoding_ARRAYSIZE =
    Chunk_Encoding_Encoding_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Encoding_descriptor() {
    return Chunk_Encoding_descriptor();
  }
  template<typename T>
  static inline const std::string& Encoding_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Encoding>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Encoding_Name.");
    return Chunk_Encoding_Name(enum_t_value);
  }
  static inline bool Encoding_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Encoding* value) {
    return Chunk_Encoding_Parse(name, value);
  }

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

  enum : int {
    kDataFieldNumber = 4,
    kMinTimeMsFieldNumber = 1,
    kMaxTimeMsFieldNumber = 2,
    kTypeFieldNumber = 3,
  };
  // bytes data = 4;
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // int64 min_time_ms = 1;
  void clear_min_time_ms();
  int64_t min_time_ms() const;
  void set_min_time_ms(int64_t value);
  private:
  int64_t _internal_min_time_ms() const;
  void _internal_set_min_time_ms(int64_t value);
  public:

  // int64 max_time_ms = 2;
  void clear_max_time_ms();
  int64_t max_time_ms() const;
  void set_max_time_ms(int64_t value);
  private:
  int64_t _internal_max_time_ms() const;
  void _internal_set_max_time_ms(int64_t value);
  public:

  // .prometheus.Chunk.Encoding type = 3;
  void clear_type();
  ::prometheus::Chunk_Encoding type() const;
  void set_type(::prometheus::Chunk_Encoding value);
  private:
  ::prometheus::Chunk_Encoding _internal_type() const;
  void _internal_set_type(::prometheus::Chunk_Encoding value);
  public:

  // @@protoc_insertion_point(class_scope:prometheus.Chunk)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    int64_t min_time_ms_;
    int64_t max_time_ms_;
    int type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ChunkedSeries& operator=(const ChunkedSeries& from) {
    CopyFrom(from);
    return *this;
  }
  inline ChunkedSeries& operator=(ChunkedSeries&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ChunkedSeries& default_instance() {
    return *internal_default_instance();
  }
  static inline const ChunkedSeries* internal_default_instance() {
    return reinterpret_cast<const ChunkedSeries*>(
               &_ChunkedSeries_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(ChunkedSeries& a, ChunkedSeries& b) {
    a.Swap(&b);
  }
  inline void Swap(ChunkedSeries* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ChunkedSeries* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ChunkedSeries* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ChunkedSeries>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ChunkedSeries& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ChunkedSeries& from) {
    ChunkedSeries::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ChunkedSeries* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "prometheus.ChunkedSeries";
  }
  protected:
  explicit ChunkedSeries(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLabelsFieldNumber = 1,
    kChunksFieldNumber = 2,
  };
  // repeated .prometheus.Label labels = 1;
  int labels_size() const;
  private:
  int _internal_labels_size() const;
  public:
  void clear_labels();
  ::prometheus::Label* mutable_labels(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >*
      mutable_labels();
  private:
  const ::prometheus::Label& _internal_labels(int index) const;
  ::prometheus::Label* _internal_add_labels();
  public:
  const ::prometheus::Label& labels(int index) const;
  ::prometheus::Label* add_labels();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >&
      labels() const;

  // repeated .prometheus.Chunk chunks = 2;
  int chunks_size() const;
  private:
  int _internal_chunks_size() const;
  public:
  void clear_chunks();
  ::prometheus::Chunk* mutable_chunks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Chunk >*
      mutable_chunks();
  private:
  const ::prometheus::Chunk& _internal_chunks(int index) const;
  ::prometheus::Chunk* _internal_add_chunks();
  public:
  const ::prometheus::Chunk& chunks(int index) const;
  ::prometheus::Chunk* add_chunks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Chunk >&
      chunks() const;

  // @@protoc_insertion_point(class_scope:prometheus.ChunkedSeries)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label > labels_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Chunk > chunks_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_prometheus_2fremote_2ftypes_2eproto;
};
// ===================================================================


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

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

// .prometheus.MetricMetadata.MetricType type = 1;
inline void MetricMetadata::clear_type() {
  _impl_.type_ = 0;
}
inline ::prometheus::MetricMetadata_MetricType MetricMetadata::_internal_type() const {
  return static_cast< ::prometheus::MetricMetadata_MetricType >(_impl_.type_);
}
inline ::prometheus::MetricMetadata_MetricType MetricMetadata::type() const {
  // @@protoc_insertion_point(field_get:prometheus.MetricMetadata.type)
  return _internal_type();
}
inline void MetricMetadata::_internal_set_type(::prometheus::MetricMetadata_MetricType value) {
  
  _impl_.type_ = value;
}
inline void MetricMetadata::set_type(::prometheus::MetricMetadata_MetricType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:prometheus.MetricMetadata.type)
}

// string metric_family_name = 2;
inline void MetricMetadata::clear_metric_family_name() {
  _impl_.metric_family_name_.ClearToEmpty();
}
inline const std::string& MetricMetadata::metric_family_name() const {
  // @@protoc_insertion_point(field_get:prometheus.MetricMetadata.metric_family_name)
  return _internal_metric_family_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MetricMetadata::set_metric_family_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.metric_family_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.MetricMetadata.metric_family_name)
}
inline std::string* MetricMetadata::mutable_metric_family_name() {
  std::string* _s = _internal_mutable_metric_family_name();
  // @@protoc_insertion_point(field_mutable:prometheus.MetricMetadata.metric_family_name)
  return _s;
}
inline const std::string& MetricMetadata::_internal_metric_family_name() const {
  return _impl_.metric_family_name_.Get();
}
inline void MetricMetadata::_internal_set_metric_family_name(const std::string& value) {
  
  _impl_.metric_family_name_.Set(value, GetArenaForAllocation());
}
inline std::string* MetricMetadata::_internal_mutable_metric_family_name() {
  
  return _impl_.metric_family_name_.Mutable(GetArenaForAllocation());
}
inline std::string* MetricMetadata::release_metric_family_name() {
  // @@protoc_insertion_point(field_release:prometheus.MetricMetadata.metric_family_name)
  return _impl_.metric_family_name_.Release();
}
inline void MetricMetadata::set_allocated_metric_family_name(std::string* metric_family_name) {
  if (metric_family_name != nullptr) {
    
  } else {
    
  }
  _impl_.metric_family_name_.SetAllocated(metric_family_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.metric_family_name_.IsDefault()) {
    _impl_.metric_family_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.MetricMetadata.metric_family_name)
}

// string help = 4;
inline void MetricMetadata::clear_help() {
  _impl_.help_.ClearToEmpty();
}
inline const std::string& MetricMetadata::help() const {
  // @@protoc_insertion_point(field_get:prometheus.MetricMetadata.help)
  return _internal_help();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MetricMetadata::set_help(ArgT0&& arg0, ArgT... args) {
 
 _impl_.help_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.MetricMetadata.help)
}
inline std::string* MetricMetadata::mutable_help() {
  std::string* _s = _internal_mutable_help();
  // @@protoc_insertion_point(field_mutable:prometheus.MetricMetadata.help)
  return _s;
}
inline const std::string& MetricMetadata::_internal_help() const {
  return _impl_.help_.Get();
}
inline void MetricMetadata::_internal_set_help(const std::string& value) {
  
  _impl_.help_.Set(value, GetArenaForAllocation());
}
inline std::string* MetricMetadata::_internal_mutable_help() {
  
  return _impl_.help_.Mutable(GetArenaForAllocation());
}
inline std::string* MetricMetadata::release_help() {
  // @@protoc_insertion_point(field_release:prometheus.MetricMetadata.help)
  return _impl_.help_.Release();
}
inline void MetricMetadata::set_allocated_help(std::string* help) {
  if (help != nullptr) {
    
  } else {
    
  }
  _impl_.help_.SetAllocated(help, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.help_.IsDefault()) {
    _impl_.help_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.MetricMetadata.help)
}

// string unit = 5;
inline void MetricMetadata::clear_unit() {
  _impl_.unit_.ClearToEmpty();
}
inline const std::string& MetricMetadata::unit() const {
  // @@protoc_insertion_point(field_get:prometheus.MetricMetadata.unit)
  return _internal_unit();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MetricMetadata::set_unit(ArgT0&& arg0, ArgT... args) {
 
 _impl_.unit_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.MetricMetadata.unit)
}
inline std::string* MetricMetadata::mutable_unit() {
  std::string* _s = _internal_mutable_unit();
  // @@protoc_insertion_point(field_mutable:prometheus.MetricMetadata.unit)
  return _s;
}
inline const std::string& MetricMetadata::_internal_unit() const {
  return _impl_.unit_.Get();
}
inline void MetricMetadata::_internal_set_unit(const std::string& value) {
  
  _impl_.unit_.Set(value, GetArenaForAllocation());
}
inline std::string* MetricMetadata::_internal_mutable_unit() {
  
  return _impl_.unit_.Mutable(GetArenaForAllocation());
}
inline std::string* MetricMetadata::release_unit() {
  // @@protoc_insertion_point(field_release:prometheus.MetricMetadata.unit)
  return _impl_.unit_.Release();
}
inline void MetricMetadata::set_allocated_unit(std::string* unit) {
  if (unit != nullptr) {
    
  } else {
    
  }
  _impl_.unit_.SetAllocated(unit, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.unit_.IsDefault()) {
    _impl_.unit_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.MetricMetadata.unit)
}

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

// Sample

// double value = 1;
inline void Sample::clear_value() {
  _impl_.value_ = 0;
}
inline double Sample::_internal_value() const {
  return _impl_.value_;
}
inline double Sample::value() const {
  // @@protoc_insertion_point(field_get:prometheus.Sample.value)
  return _internal_value();
}
inline void Sample::_internal_set_value(double value) {
  
  _impl_.value_ = value;
}
inline void Sample::set_value(double value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:prometheus.Sample.value)
}

// int64 timestamp = 2;
inline void Sample::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
}
inline int64_t Sample::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t Sample::timestamp() const {
  // @@protoc_insertion_point(field_get:prometheus.Sample.timestamp)
  return _internal_timestamp();
}
inline void Sample::_internal_set_timestamp(int64_t value) {
  
  _impl_.timestamp_ = value;
}
inline void Sample::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:prometheus.Sample.timestamp)
}

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

// Exemplar

// repeated .prometheus.Label labels = 1;
inline int Exemplar::_internal_labels_size() const {
  return _impl_.labels_.size();
}
inline int Exemplar::labels_size() const {
  return _internal_labels_size();
}
inline void Exemplar::clear_labels() {
  _impl_.labels_.Clear();
}
inline ::prometheus::Label* Exemplar::mutable_labels(int index) {
  // @@protoc_insertion_point(field_mutable:prometheus.Exemplar.labels)
  return _impl_.labels_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >*
Exemplar::mutable_labels() {
  // @@protoc_insertion_point(field_mutable_list:prometheus.Exemplar.labels)
  return &_impl_.labels_;
}
inline const ::prometheus::Label& Exemplar::_internal_labels(int index) const {
  return _impl_.labels_.Get(index);
}
inline const ::prometheus::Label& Exemplar::labels(int index) const {
  // @@protoc_insertion_point(field_get:prometheus.Exemplar.labels)
  return _internal_labels(index);
}
inline ::prometheus::Label* Exemplar::_internal_add_labels() {
  return _impl_.labels_.Add();
}
inline ::prometheus::Label* Exemplar::add_labels() {
  ::prometheus::Label* _add = _internal_add_labels();
  // @@protoc_insertion_point(field_add:prometheus.Exemplar.labels)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >&
Exemplar::labels() const {
  // @@protoc_insertion_point(field_list:prometheus.Exemplar.labels)
  return _impl_.labels_;
}

// double value = 2;
inline void Exemplar::clear_value() {
  _impl_.value_ = 0;
}
inline double Exemplar::_internal_value() const {
  return _impl_.value_;
}
inline double Exemplar::value() const {
  // @@protoc_insertion_point(field_get:prometheus.Exemplar.value)
  return _internal_value();
}
inline void Exemplar::_internal_set_value(double value) {
  
  _impl_.value_ = value;
}
inline void Exemplar::set_value(double value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:prometheus.Exemplar.value)
}

// int64 timestamp = 3;
inline void Exemplar::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
}
inline int64_t Exemplar::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t Exemplar::timestamp() const {
  // @@protoc_insertion_point(field_get:prometheus.Exemplar.timestamp)
  return _internal_timestamp();
}
inline void Exemplar::_internal_set_timestamp(int64_t value) {
  
  _impl_.timestamp_ = value;
}
inline void Exemplar::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:prometheus.Exemplar.timestamp)
}

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

// TimeSeries

// repeated .prometheus.Label labels = 1;
inline int TimeSeries::_internal_labels_size() const {
  return _impl_.labels_.size();
}
inline int TimeSeries::labels_size() const {
  return _internal_labels_size();
}
inline void TimeSeries::clear_labels() {
  _impl_.labels_.Clear();
}
inline ::prometheus::Label* TimeSeries::mutable_labels(int index) {
  // @@protoc_insertion_point(field_mutable:prometheus.TimeSeries.labels)
  return _impl_.labels_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >*
TimeSeries::mutable_labels() {
  // @@protoc_insertion_point(field_mutable_list:prometheus.TimeSeries.labels)
  return &_impl_.labels_;
}
inline const ::prometheus::Label& TimeSeries::_internal_labels(int index) const {
  return _impl_.labels_.Get(index);
}
inline const ::prometheus::Label& TimeSeries::labels(int index) const {
  // @@protoc_insertion_point(field_get:prometheus.TimeSeries.labels)
  return _internal_labels(index);
}
inline ::prometheus::Label* TimeSeries::_internal_add_labels() {
  return _impl_.labels_.Add();
}
inline ::prometheus::Label* TimeSeries::add_labels() {
  ::prometheus::Label* _add = _internal_add_labels();
  // @@protoc_insertion_point(field_add:prometheus.TimeSeries.labels)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >&
TimeSeries::labels() const {
  // @@protoc_insertion_point(field_list:prometheus.TimeSeries.labels)
  return _impl_.labels_;
}

// repeated .prometheus.Sample samples = 2;
inline int TimeSeries::_internal_samples_size() const {
  return _impl_.samples_.size();
}
inline int TimeSeries::samples_size() const {
  return _internal_samples_size();
}
inline void TimeSeries::clear_samples() {
  _impl_.samples_.Clear();
}
inline ::prometheus::Sample* TimeSeries::mutable_samples(int index) {
  // @@protoc_insertion_point(field_mutable:prometheus.TimeSeries.samples)
  return _impl_.samples_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Sample >*
TimeSeries::mutable_samples() {
  // @@protoc_insertion_point(field_mutable_list:prometheus.TimeSeries.samples)
  return &_impl_.samples_;
}
inline const ::prometheus::Sample& TimeSeries::_internal_samples(int index) const {
  return _impl_.samples_.Get(index);
}
inline const ::prometheus::Sample& TimeSeries::samples(int index) const {
  // @@protoc_insertion_point(field_get:prometheus.TimeSeries.samples)
  return _internal_samples(index);
}
inline ::prometheus::Sample* TimeSeries::_internal_add_samples() {
  return _impl_.samples_.Add();
}
inline ::prometheus::Sample* TimeSeries::add_samples() {
  ::prometheus::Sample* _add = _internal_add_samples();
  // @@protoc_insertion_point(field_add:prometheus.TimeSeries.samples)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Sample >&
TimeSeries::samples() const {
  // @@protoc_insertion_point(field_list:prometheus.TimeSeries.samples)
  return _impl_.samples_;
}

// repeated .prometheus.Exemplar exemplars = 3;
inline int TimeSeries::_internal_exemplars_size() const {
  return _impl_.exemplars_.size();
}
inline int TimeSeries::exemplars_size() const {
  return _internal_exemplars_size();
}
inline void TimeSeries::clear_exemplars() {
  _impl_.exemplars_.Clear();
}
inline ::prometheus::Exemplar* TimeSeries::mutable_exemplars(int index) {
  // @@protoc_insertion_point(field_mutable:prometheus.TimeSeries.exemplars)
  return _impl_.exemplars_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Exemplar >*
TimeSeries::mutable_exemplars() {
  // @@protoc_insertion_point(field_mutable_list:prometheus.TimeSeries.exemplars)
  return &_impl_.exemplars_;
}
inline const ::prometheus::Exemplar& TimeSeries::_internal_exemplars(int index) const {
  return _impl_.exemplars_.Get(index);
}
inline const ::prometheus::Exemplar& TimeSeries::exemplars(int index) const {
  // @@protoc_insertion_point(field_get:prometheus.TimeSeries.exemplars)
  return _internal_exemplars(index);
}
inline ::prometheus::Exemplar* TimeSeries::_internal_add_exemplars() {
  return _impl_.exemplars_.Add();
}
inline ::prometheus::Exemplar* TimeSeries::add_exemplars() {
  ::prometheus::Exemplar* _add = _internal_add_exemplars();
  // @@protoc_insertion_point(field_add:prometheus.TimeSeries.exemplars)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Exemplar >&
TimeSeries::exemplars() const {
  // @@protoc_insertion_point(field_list:prometheus.TimeSeries.exemplars)
  return _impl_.exemplars_;
}

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

// Label

// string name = 1;
inline void Label::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Label::name() const {
  // @@protoc_insertion_point(field_get:prometheus.Label.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Label::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.Label.name)
}
inline std::string* Label::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:prometheus.Label.name)
  return _s;
}
inline const std::string& Label::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Label::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Label::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Label::release_name() {
  // @@protoc_insertion_point(field_release:prometheus.Label.name)
  return _impl_.name_.Release();
}
inline void Label::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.Label.name)
}

// string value = 2;
inline void Label::clear_value() {
  _impl_.value_.ClearToEmpty();
}
inline const std::string& Label::value() const {
  // @@protoc_insertion_point(field_get:prometheus.Label.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Label::set_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.Label.value)
}
inline std::string* Label::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:prometheus.Label.value)
  return _s;
}
inline const std::string& Label::_internal_value() const {
  return _impl_.value_.Get();
}
inline void Label::_internal_set_value(const std::string& value) {
  
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* Label::_internal_mutable_value() {
  
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* Label::release_value() {
  // @@protoc_insertion_point(field_release:prometheus.Label.value)
  return _impl_.value_.Release();
}
inline void Label::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.Label.value)
}

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

// Labels

// repeated .prometheus.Label labels = 1;
inline int Labels::_internal_labels_size() const {
  return _impl_.labels_.size();
}
inline int Labels::labels_size() const {
  return _internal_labels_size();
}
inline void Labels::clear_labels() {
  _impl_.labels_.Clear();
}
inline ::prometheus::Label* Labels::mutable_labels(int index) {
  // @@protoc_insertion_point(field_mutable:prometheus.Labels.labels)
  return _impl_.labels_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >*
Labels::mutable_labels() {
  // @@protoc_insertion_point(field_mutable_list:prometheus.Labels.labels)
  return &_impl_.labels_;
}
inline const ::prometheus::Label& Labels::_internal_labels(int index) const {
  return _impl_.labels_.Get(index);
}
inline const ::prometheus::Label& Labels::labels(int index) const {
  // @@protoc_insertion_point(field_get:prometheus.Labels.labels)
  return _internal_labels(index);
}
inline ::prometheus::Label* Labels::_internal_add_labels() {
  return _impl_.labels_.Add();
}
inline ::prometheus::Label* Labels::add_labels() {
  ::prometheus::Label* _add = _internal_add_labels();
  // @@protoc_insertion_point(field_add:prometheus.Labels.labels)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >&
Labels::labels() const {
  // @@protoc_insertion_point(field_list:prometheus.Labels.labels)
  return _impl_.labels_;
}

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

// LabelMatcher

// .prometheus.LabelMatcher.Type type = 1;
inline void LabelMatcher::clear_type() {
  _impl_.type_ = 0;
}
inline ::prometheus::LabelMatcher_Type LabelMatcher::_internal_type() const {
  return static_cast< ::prometheus::LabelMatcher_Type >(_impl_.type_);
}
inline ::prometheus::LabelMatcher_Type LabelMatcher::type() const {
  // @@protoc_insertion_point(field_get:prometheus.LabelMatcher.type)
  return _internal_type();
}
inline void LabelMatcher::_internal_set_type(::prometheus::LabelMatcher_Type value) {
  
  _impl_.type_ = value;
}
inline void LabelMatcher::set_type(::prometheus::LabelMatcher_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:prometheus.LabelMatcher.type)
}

// string name = 2;
inline void LabelMatcher::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& LabelMatcher::name() const {
  // @@protoc_insertion_point(field_get:prometheus.LabelMatcher.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LabelMatcher::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.LabelMatcher.name)
}
inline std::string* LabelMatcher::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:prometheus.LabelMatcher.name)
  return _s;
}
inline const std::string& LabelMatcher::_internal_name() const {
  return _impl_.name_.Get();
}
inline void LabelMatcher::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* LabelMatcher::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* LabelMatcher::release_name() {
  // @@protoc_insertion_point(field_release:prometheus.LabelMatcher.name)
  return _impl_.name_.Release();
}
inline void LabelMatcher::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.LabelMatcher.name)
}

// string value = 3;
inline void LabelMatcher::clear_value() {
  _impl_.value_.ClearToEmpty();
}
inline const std::string& LabelMatcher::value() const {
  // @@protoc_insertion_point(field_get:prometheus.LabelMatcher.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LabelMatcher::set_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.LabelMatcher.value)
}
inline std::string* LabelMatcher::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:prometheus.LabelMatcher.value)
  return _s;
}
inline const std::string& LabelMatcher::_internal_value() const {
  return _impl_.value_.Get();
}
inline void LabelMatcher::_internal_set_value(const std::string& value) {
  
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* LabelMatcher::_internal_mutable_value() {
  
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* LabelMatcher::release_value() {
  // @@protoc_insertion_point(field_release:prometheus.LabelMatcher.value)
  return _impl_.value_.Release();
}
inline void LabelMatcher::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.LabelMatcher.value)
}

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

// ReadHints

// int64 step_ms = 1;
inline void ReadHints::clear_step_ms() {
  _impl_.step_ms_ = int64_t{0};
}
inline int64_t ReadHints::_internal_step_ms() const {
  return _impl_.step_ms_;
}
inline int64_t ReadHints::step_ms() const {
  // @@protoc_insertion_point(field_get:prometheus.ReadHints.step_ms)
  return _internal_step_ms();
}
inline void ReadHints::_internal_set_step_ms(int64_t value) {
  
  _impl_.step_ms_ = value;
}
inline void ReadHints::set_step_ms(int64_t value) {
  _internal_set_step_ms(value);
  // @@protoc_insertion_point(field_set:prometheus.ReadHints.step_ms)
}

// string func = 2;
inline void ReadHints::clear_func() {
  _impl_.func_.ClearToEmpty();
}
inline const std::string& ReadHints::func() const {
  // @@protoc_insertion_point(field_get:prometheus.ReadHints.func)
  return _internal_func();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReadHints::set_func(ArgT0&& arg0, ArgT... args) {
 
 _impl_.func_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.ReadHints.func)
}
inline std::string* ReadHints::mutable_func() {
  std::string* _s = _internal_mutable_func();
  // @@protoc_insertion_point(field_mutable:prometheus.ReadHints.func)
  return _s;
}
inline const std::string& ReadHints::_internal_func() const {
  return _impl_.func_.Get();
}
inline void ReadHints::_internal_set_func(const std::string& value) {
  
  _impl_.func_.Set(value, GetArenaForAllocation());
}
inline std::string* ReadHints::_internal_mutable_func() {
  
  return _impl_.func_.Mutable(GetArenaForAllocation());
}
inline std::string* ReadHints::release_func() {
  // @@protoc_insertion_point(field_release:prometheus.ReadHints.func)
  return _impl_.func_.Release();
}
inline void ReadHints::set_allocated_func(std::string* func) {
  if (func != nullptr) {
    
  } else {
    
  }
  _impl_.func_.SetAllocated(func, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.func_.IsDefault()) {
    _impl_.func_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.ReadHints.func)
}

// int64 start_ms = 3;
inline void ReadHints::clear_start_ms() {
  _impl_.start_ms_ = int64_t{0};
}
inline int64_t ReadHints::_internal_start_ms() const {
  return _impl_.start_ms_;
}
inline int64_t ReadHints::start_ms() const {
  // @@protoc_insertion_point(field_get:prometheus.ReadHints.start_ms)
  return _internal_start_ms();
}
inline void ReadHints::_internal_set_start_ms(int64_t value) {
  
  _impl_.start_ms_ = value;
}
inline void ReadHints::set_start_ms(int64_t value) {
  _internal_set_start_ms(value);
  // @@protoc_insertion_point(field_set:prometheus.ReadHints.start_ms)
}

// int64 end_ms = 4;
inline void ReadHints::clear_end_ms() {
  _impl_.end_ms_ = int64_t{0};
}
inline int64_t ReadHints::_internal_end_ms() const {
  return _impl_.end_ms_;
}
inline int64_t ReadHints::end_ms() const {
  // @@protoc_insertion_point(field_get:prometheus.ReadHints.end_ms)
  return _internal_end_ms();
}
inline void ReadHints::_internal_set_end_ms(int64_t value) {
  
  _impl_.end_ms_ = value;
}
inline void ReadHints::set_end_ms(int64_t value) {
  _internal_set_end_ms(value);
  // @@protoc_insertion_point(field_set:prometheus.ReadHints.end_ms)
}

// repeated string grouping = 5;
inline int ReadHints::_internal_grouping_size() const {
  return _impl_.grouping_.size();
}
inline int ReadHints::grouping_size() const {
  return _internal_grouping_size();
}
inline void ReadHints::clear_grouping() {
  _impl_.grouping_.Clear();
}
inline std::string* ReadHints::add_grouping() {
  std::string* _s = _internal_add_grouping();
  // @@protoc_insertion_point(field_add_mutable:prometheus.ReadHints.grouping)
  return _s;
}
inline const std::string& ReadHints::_internal_grouping(int index) const {
  return _impl_.grouping_.Get(index);
}
inline const std::string& ReadHints::grouping(int index) const {
  // @@protoc_insertion_point(field_get:prometheus.ReadHints.grouping)
  return _internal_grouping(index);
}
inline std::string* ReadHints::mutable_grouping(int index) {
  // @@protoc_insertion_point(field_mutable:prometheus.ReadHints.grouping)
  return _impl_.grouping_.Mutable(index);
}
inline void ReadHints::set_grouping(int index, const std::string& value) {
  _impl_.grouping_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:prometheus.ReadHints.grouping)
}
inline void ReadHints::set_grouping(int index, std::string&& value) {
  _impl_.grouping_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:prometheus.ReadHints.grouping)
}
inline void ReadHints::set_grouping(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.grouping_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:prometheus.ReadHints.grouping)
}
inline void ReadHints::set_grouping(int index, const char* value, size_t size) {
  _impl_.grouping_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:prometheus.ReadHints.grouping)
}
inline std::string* ReadHints::_internal_add_grouping() {
  return _impl_.grouping_.Add();
}
inline void ReadHints::add_grouping(const std::string& value) {
  _impl_.grouping_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:prometheus.ReadHints.grouping)
}
inline void ReadHints::add_grouping(std::string&& value) {
  _impl_.grouping_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:prometheus.ReadHints.grouping)
}
inline void ReadHints::add_grouping(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.grouping_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:prometheus.ReadHints.grouping)
}
inline void ReadHints::add_grouping(const char* value, size_t size) {
  _impl_.grouping_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:prometheus.ReadHints.grouping)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ReadHints::grouping() const {
  // @@protoc_insertion_point(field_list:prometheus.ReadHints.grouping)
  return _impl_.grouping_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ReadHints::mutable_grouping() {
  // @@protoc_insertion_point(field_mutable_list:prometheus.ReadHints.grouping)
  return &_impl_.grouping_;
}

// bool by = 6;
inline void ReadHints::clear_by() {
  _impl_.by_ = false;
}
inline bool ReadHints::_internal_by() const {
  return _impl_.by_;
}
inline bool ReadHints::by() const {
  // @@protoc_insertion_point(field_get:prometheus.ReadHints.by)
  return _internal_by();
}
inline void ReadHints::_internal_set_by(bool value) {
  
  _impl_.by_ = value;
}
inline void ReadHints::set_by(bool value) {
  _internal_set_by(value);
  // @@protoc_insertion_point(field_set:prometheus.ReadHints.by)
}

// int64 range_ms = 7;
inline void ReadHints::clear_range_ms() {
  _impl_.range_ms_ = int64_t{0};
}
inline int64_t ReadHints::_internal_range_ms() const {
  return _impl_.range_ms_;
}
inline int64_t ReadHints::range_ms() const {
  // @@protoc_insertion_point(field_get:prometheus.ReadHints.range_ms)
  return _internal_range_ms();
}
inline void ReadHints::_internal_set_range_ms(int64_t value) {
  
  _impl_.range_ms_ = value;
}
inline void ReadHints::set_range_ms(int64_t value) {
  _internal_set_range_ms(value);
  // @@protoc_insertion_point(field_set:prometheus.ReadHints.range_ms)
}

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

// Chunk

// int64 min_time_ms = 1;
inline void Chunk::clear_min_time_ms() {
  _impl_.min_time_ms_ = int64_t{0};
}
inline int64_t Chunk::_internal_min_time_ms() const {
  return _impl_.min_time_ms_;
}
inline int64_t Chunk::min_time_ms() const {
  // @@protoc_insertion_point(field_get:prometheus.Chunk.min_time_ms)
  return _internal_min_time_ms();
}
inline void Chunk::_internal_set_min_time_ms(int64_t value) {
  
  _impl_.min_time_ms_ = value;
}
inline void Chunk::set_min_time_ms(int64_t value) {
  _internal_set_min_time_ms(value);
  // @@protoc_insertion_point(field_set:prometheus.Chunk.min_time_ms)
}

// int64 max_time_ms = 2;
inline void Chunk::clear_max_time_ms() {
  _impl_.max_time_ms_ = int64_t{0};
}
inline int64_t Chunk::_internal_max_time_ms() const {
  return _impl_.max_time_ms_;
}
inline int64_t Chunk::max_time_ms() const {
  // @@protoc_insertion_point(field_get:prometheus.Chunk.max_time_ms)
  return _internal_max_time_ms();
}
inline void Chunk::_internal_set_max_time_ms(int64_t value) {
  
  _impl_.max_time_ms_ = value;
}
inline void Chunk::set_max_time_ms(int64_t value) {
  _internal_set_max_time_ms(value);
  // @@protoc_insertion_point(field_set:prometheus.Chunk.max_time_ms)
}

// .prometheus.Chunk.Encoding type = 3;
inline void Chunk::clear_type() {
  _impl_.type_ = 0;
}
inline ::prometheus::Chunk_Encoding Chunk::_internal_type() const {
  return static_cast< ::prometheus::Chunk_Encoding >(_impl_.type_);
}
inline ::prometheus::Chunk_Encoding Chunk::type() const {
  // @@protoc_insertion_point(field_get:prometheus.Chunk.type)
  return _internal_type();
}
inline void Chunk::_internal_set_type(::prometheus::Chunk_Encoding value) {
  
  _impl_.type_ = value;
}
inline void Chunk::set_type(::prometheus::Chunk_Encoding value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:prometheus.Chunk.type)
}

// bytes data = 4;
inline void Chunk::clear_data() {
  _impl_.data_.ClearToEmpty();
}
inline const std::string& Chunk::data() const {
  // @@protoc_insertion_point(field_get:prometheus.Chunk.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Chunk::set_data(ArgT0&& arg0, ArgT... args) {
 
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:prometheus.Chunk.data)
}
inline std::string* Chunk::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:prometheus.Chunk.data)
  return _s;
}
inline const std::string& Chunk::_internal_data() const {
  return _impl_.data_.Get();
}
inline void Chunk::_internal_set_data(const std::string& value) {
  
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* Chunk::_internal_mutable_data() {
  
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* Chunk::release_data() {
  // @@protoc_insertion_point(field_release:prometheus.Chunk.data)
  return _impl_.data_.Release();
}
inline void Chunk::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    
  } else {
    
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:prometheus.Chunk.data)
}

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

// ChunkedSeries

// repeated .prometheus.Label labels = 1;
inline int ChunkedSeries::_internal_labels_size() const {
  return _impl_.labels_.size();
}
inline int ChunkedSeries::labels_size() const {
  return _internal_labels_size();
}
inline void ChunkedSeries::clear_labels() {
  _impl_.labels_.Clear();
}
inline ::prometheus::Label* ChunkedSeries::mutable_labels(int index) {
  // @@protoc_insertion_point(field_mutable:prometheus.ChunkedSeries.labels)
  return _impl_.labels_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >*
ChunkedSeries::mutable_labels() {
  // @@protoc_insertion_point(field_mutable_list:prometheus.ChunkedSeries.labels)
  return &_impl_.labels_;
}
inline const ::prometheus::Label& ChunkedSeries::_internal_labels(int index) const {
  return _impl_.labels_.Get(index);
}
inline const ::prometheus::Label& ChunkedSeries::labels(int index) const {
  // @@protoc_insertion_point(field_get:prometheus.ChunkedSeries.labels)
  return _internal_labels(index);
}
inline ::prometheus::Label* ChunkedSeries::_internal_add_labels() {
  return _impl_.labels_.Add();
}
inline ::prometheus::Label* ChunkedSeries::add_labels() {
  ::prometheus::Label* _add = _internal_add_labels();
  // @@protoc_insertion_point(field_add:prometheus.ChunkedSeries.labels)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Label >&
ChunkedSeries::labels() const {
  // @@protoc_insertion_point(field_list:prometheus.ChunkedSeries.labels)
  return _impl_.labels_;
}

// repeated .prometheus.Chunk chunks = 2;
inline int ChunkedSeries::_internal_chunks_size() const {
  return _impl_.chunks_.size();
}
inline int ChunkedSeries::chunks_size() const {
  return _internal_chunks_size();
}
inline void ChunkedSeries::clear_chunks() {
  _impl_.chunks_.Clear();
}
inline ::prometheus::Chunk* ChunkedSeries::mutable_chunks(int index) {
  // @@protoc_insertion_point(field_mutable:prometheus.ChunkedSeries.chunks)
  return _impl_.chunks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Chunk >*
ChunkedSeries::mutable_chunks() {
  // @@protoc_insertion_point(field_mutable_list:prometheus.ChunkedSeries.chunks)
  return &_impl_.chunks_;
}
inline const ::prometheus::Chunk& ChunkedSeries::_internal_chunks(int index) const {
  return _impl_.chunks_.Get(index);
}
inline const ::prometheus::Chunk& ChunkedSeries::chunks(int index) const {
  // @@protoc_insertion_point(field_get:prometheus.ChunkedSeries.chunks)
  return _internal_chunks(index);
}
inline ::prometheus::Chunk* ChunkedSeries::_internal_add_chunks() {
  return _impl_.chunks_.Add();
}
inline ::prometheus::Chunk* ChunkedSeries::add_chunks() {
  ::prometheus::Chunk* _add = _internal_add_chunks();
  // @@protoc_insertion_point(field_add:prometheus.ChunkedSeries.chunks)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::prometheus::Chunk >&
ChunkedSeries::chunks() const {
  // @@protoc_insertion_point(field_list:prometheus.ChunkedSeries.chunks)
  return _impl_.chunks_;
}

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace prometheus

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::prometheus::MetricMetadata_MetricType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::prometheus::MetricMetadata_MetricType>() {
  return ::prometheus::MetricMetadata_MetricType_descriptor();
}
template <> struct is_proto_enum< ::prometheus::LabelMatcher_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::prometheus::LabelMatcher_Type>() {
  return ::prometheus::LabelMatcher_Type_descriptor();
}
template <> struct is_proto_enum< ::prometheus::Chunk_Encoding> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::prometheus::Chunk_Encoding>() {
  return ::prometheus::Chunk_Encoding_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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