// This file is generated by rust-protobuf 2.24.1. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `opentelemetry/proto/metrics/v1/metrics.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_24_1;

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct ResourceMetrics {
    // message fields
    pub resource: ::protobuf::SingularPtrField<super::resource::Resource>,
    pub instrumentation_library_metrics: ::protobuf::RepeatedField<InstrumentationLibraryMetrics>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ResourceMetrics {
    fn default() -> &'a ResourceMetrics {
        <ResourceMetrics as ::protobuf::Message>::default_instance()
    }
}

impl ResourceMetrics {
    pub fn new() -> ResourceMetrics {
        ::std::default::Default::default()
    }

    // .opentelemetry.proto.resource.v1.Resource resource = 1;


    pub fn get_resource(&self) -> &super::resource::Resource {
        self.resource.as_ref().unwrap_or_else(|| <super::resource::Resource as ::protobuf::Message>::default_instance())
    }
    pub fn clear_resource(&mut self) {
        self.resource.clear();
    }

    pub fn has_resource(&self) -> bool {
        self.resource.is_some()
    }

    // Param is passed by value, moved
    pub fn set_resource(&mut self, v: super::resource::Resource) {
        self.resource = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_resource(&mut self) -> &mut super::resource::Resource {
        if self.resource.is_none() {
            self.resource.set_default();
        }
        self.resource.as_mut().unwrap()
    }

    // Take field
    pub fn take_resource(&mut self) -> super::resource::Resource {
        self.resource.take().unwrap_or_else(|| super::resource::Resource::new())
    }

    // repeated .opentelemetry.proto.metrics.v1.InstrumentationLibraryMetrics instrumentation_library_metrics = 2;


    pub fn get_instrumentation_library_metrics(&self) -> &[InstrumentationLibraryMetrics] {
        &self.instrumentation_library_metrics
    }
    pub fn clear_instrumentation_library_metrics(&mut self) {
        self.instrumentation_library_metrics.clear();
    }

    // Param is passed by value, moved
    pub fn set_instrumentation_library_metrics(&mut self, v: ::protobuf::RepeatedField<InstrumentationLibraryMetrics>) {
        self.instrumentation_library_metrics = v;
    }

    // Mutable pointer to the field.
    pub fn mut_instrumentation_library_metrics(&mut self) -> &mut ::protobuf::RepeatedField<InstrumentationLibraryMetrics> {
        &mut self.instrumentation_library_metrics
    }

    // Take field
    pub fn take_instrumentation_library_metrics(&mut self) -> ::protobuf::RepeatedField<InstrumentationLibraryMetrics> {
        ::std::mem::replace(&mut self.instrumentation_library_metrics, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ResourceMetrics {
    fn is_initialized(&self) -> bool {
        for v in &self.resource {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.instrumentation_library_metrics {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.resource)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.instrumentation_library_metrics)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.resource.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.instrumentation_library_metrics {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.resource.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.instrumentation_library_metrics {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ResourceMetrics {
        ResourceMetrics::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::resource::Resource>>(
                "resource",
                |m: &ResourceMetrics| { &m.resource },
                |m: &mut ResourceMetrics| { &mut m.resource },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<InstrumentationLibraryMetrics>>(
                "instrumentation_library_metrics",
                |m: &ResourceMetrics| { &m.instrumentation_library_metrics },
                |m: &mut ResourceMetrics| { &mut m.instrumentation_library_metrics },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResourceMetrics>(
                "ResourceMetrics",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ResourceMetrics {
        static instance: ::protobuf::rt::LazyV2<ResourceMetrics> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ResourceMetrics::new)
    }
}

impl ::protobuf::Clear for ResourceMetrics {
    fn clear(&mut self) {
        self.resource.clear();
        self.instrumentation_library_metrics.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ResourceMetrics {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ResourceMetrics {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct InstrumentationLibraryMetrics {
    // message fields
    pub instrumentation_library: ::protobuf::SingularPtrField<super::common::InstrumentationLibrary>,
    pub metrics: ::protobuf::RepeatedField<Metric>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a InstrumentationLibraryMetrics {
    fn default() -> &'a InstrumentationLibraryMetrics {
        <InstrumentationLibraryMetrics as ::protobuf::Message>::default_instance()
    }
}

impl InstrumentationLibraryMetrics {
    pub fn new() -> InstrumentationLibraryMetrics {
        ::std::default::Default::default()
    }

    // .opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = 1;


    pub fn get_instrumentation_library(&self) -> &super::common::InstrumentationLibrary {
        self.instrumentation_library.as_ref().unwrap_or_else(|| <super::common::InstrumentationLibrary as ::protobuf::Message>::default_instance())
    }
    pub fn clear_instrumentation_library(&mut self) {
        self.instrumentation_library.clear();
    }

    pub fn has_instrumentation_library(&self) -> bool {
        self.instrumentation_library.is_some()
    }

    // Param is passed by value, moved
    pub fn set_instrumentation_library(&mut self, v: super::common::InstrumentationLibrary) {
        self.instrumentation_library = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_instrumentation_library(&mut self) -> &mut super::common::InstrumentationLibrary {
        if self.instrumentation_library.is_none() {
            self.instrumentation_library.set_default();
        }
        self.instrumentation_library.as_mut().unwrap()
    }

    // Take field
    pub fn take_instrumentation_library(&mut self) -> super::common::InstrumentationLibrary {
        self.instrumentation_library.take().unwrap_or_else(|| super::common::InstrumentationLibrary::new())
    }

    // repeated .opentelemetry.proto.metrics.v1.Metric metrics = 2;


    pub fn get_metrics(&self) -> &[Metric] {
        &self.metrics
    }
    pub fn clear_metrics(&mut self) {
        self.metrics.clear();
    }

    // Param is passed by value, moved
    pub fn set_metrics(&mut self, v: ::protobuf::RepeatedField<Metric>) {
        self.metrics = v;
    }

    // Mutable pointer to the field.
    pub fn mut_metrics(&mut self) -> &mut ::protobuf::RepeatedField<Metric> {
        &mut self.metrics
    }

    // Take field
    pub fn take_metrics(&mut self) -> ::protobuf::RepeatedField<Metric> {
        ::std::mem::replace(&mut self.metrics, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for InstrumentationLibraryMetrics {
    fn is_initialized(&self) -> bool {
        for v in &self.instrumentation_library {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.metrics {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.instrumentation_library)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.metrics)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.instrumentation_library.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.metrics {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.instrumentation_library.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.metrics {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> InstrumentationLibraryMetrics {
        InstrumentationLibraryMetrics::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::InstrumentationLibrary>>(
                "instrumentation_library",
                |m: &InstrumentationLibraryMetrics| { &m.instrumentation_library },
                |m: &mut InstrumentationLibraryMetrics| { &mut m.instrumentation_library },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Metric>>(
                "metrics",
                |m: &InstrumentationLibraryMetrics| { &m.metrics },
                |m: &mut InstrumentationLibraryMetrics| { &mut m.metrics },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<InstrumentationLibraryMetrics>(
                "InstrumentationLibraryMetrics",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static InstrumentationLibraryMetrics {
        static instance: ::protobuf::rt::LazyV2<InstrumentationLibraryMetrics> = ::protobuf::rt::LazyV2::INIT;
        instance.get(InstrumentationLibraryMetrics::new)
    }
}

impl ::protobuf::Clear for InstrumentationLibraryMetrics {
    fn clear(&mut self) {
        self.instrumentation_library.clear();
        self.metrics.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for InstrumentationLibraryMetrics {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for InstrumentationLibraryMetrics {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct Metric {
    // message fields
    pub name: ::std::string::String,
    pub description: ::std::string::String,
    pub unit: ::std::string::String,
    // message oneof groups
    pub data: ::std::option::Option<Metric_oneof_data>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Metric {
    fn default() -> &'a Metric {
        <Metric as ::protobuf::Message>::default_instance()
    }
}

#[derive(Clone,PartialEq,Debug)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub enum Metric_oneof_data {
    int_gauge(IntGauge),
    gauge(Gauge),
    int_sum(IntSum),
    sum(Sum),
    int_histogram(IntHistogram),
    histogram(Histogram),
    summary(Summary),
}

impl Metric {
    pub fn new() -> Metric {
        ::std::default::Default::default()
    }

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // string description = 2;


    pub fn get_description(&self) -> &str {
        &self.description
    }
    pub fn clear_description(&mut self) {
        self.description.clear();
    }

    // Param is passed by value, moved
    pub fn set_description(&mut self, v: ::std::string::String) {
        self.description = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_description(&mut self) -> &mut ::std::string::String {
        &mut self.description
    }

    // Take field
    pub fn take_description(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.description, ::std::string::String::new())
    }

    // string unit = 3;


    pub fn get_unit(&self) -> &str {
        &self.unit
    }
    pub fn clear_unit(&mut self) {
        self.unit.clear();
    }

    // Param is passed by value, moved
    pub fn set_unit(&mut self, v: ::std::string::String) {
        self.unit = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_unit(&mut self) -> &mut ::std::string::String {
        &mut self.unit
    }

    // Take field
    pub fn take_unit(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.unit, ::std::string::String::new())
    }

    // .opentelemetry.proto.metrics.v1.IntGauge int_gauge = 4;


    pub fn get_int_gauge(&self) -> &IntGauge {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_gauge(ref v)) => v,
            _ => <IntGauge as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_int_gauge(&mut self) {
        self.data = ::std::option::Option::None;
    }

    pub fn has_int_gauge(&self) -> bool {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_gauge(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int_gauge(&mut self, v: IntGauge) {
        self.data = ::std::option::Option::Some(Metric_oneof_data::int_gauge(v))
    }

    // Mutable pointer to the field.
    pub fn mut_int_gauge(&mut self) -> &mut IntGauge {
        if let ::std::option::Option::Some(Metric_oneof_data::int_gauge(_)) = self.data {
        } else {
            self.data = ::std::option::Option::Some(Metric_oneof_data::int_gauge(IntGauge::new()));
        }
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_gauge(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_int_gauge(&mut self) -> IntGauge {
        if self.has_int_gauge() {
            match self.data.take() {
                ::std::option::Option::Some(Metric_oneof_data::int_gauge(v)) => v,
                _ => panic!(),
            }
        } else {
            IntGauge::new()
        }
    }

    // .opentelemetry.proto.metrics.v1.Gauge gauge = 5;


    pub fn get_gauge(&self) -> &Gauge {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::gauge(ref v)) => v,
            _ => <Gauge as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_gauge(&mut self) {
        self.data = ::std::option::Option::None;
    }

    pub fn has_gauge(&self) -> bool {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::gauge(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_gauge(&mut self, v: Gauge) {
        self.data = ::std::option::Option::Some(Metric_oneof_data::gauge(v))
    }

    // Mutable pointer to the field.
    pub fn mut_gauge(&mut self) -> &mut Gauge {
        if let ::std::option::Option::Some(Metric_oneof_data::gauge(_)) = self.data {
        } else {
            self.data = ::std::option::Option::Some(Metric_oneof_data::gauge(Gauge::new()));
        }
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::gauge(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_gauge(&mut self) -> Gauge {
        if self.has_gauge() {
            match self.data.take() {
                ::std::option::Option::Some(Metric_oneof_data::gauge(v)) => v,
                _ => panic!(),
            }
        } else {
            Gauge::new()
        }
    }

    // .opentelemetry.proto.metrics.v1.IntSum int_sum = 6;


    pub fn get_int_sum(&self) -> &IntSum {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_sum(ref v)) => v,
            _ => <IntSum as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_int_sum(&mut self) {
        self.data = ::std::option::Option::None;
    }

    pub fn has_int_sum(&self) -> bool {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_sum(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int_sum(&mut self, v: IntSum) {
        self.data = ::std::option::Option::Some(Metric_oneof_data::int_sum(v))
    }

    // Mutable pointer to the field.
    pub fn mut_int_sum(&mut self) -> &mut IntSum {
        if let ::std::option::Option::Some(Metric_oneof_data::int_sum(_)) = self.data {
        } else {
            self.data = ::std::option::Option::Some(Metric_oneof_data::int_sum(IntSum::new()));
        }
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_sum(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_int_sum(&mut self) -> IntSum {
        if self.has_int_sum() {
            match self.data.take() {
                ::std::option::Option::Some(Metric_oneof_data::int_sum(v)) => v,
                _ => panic!(),
            }
        } else {
            IntSum::new()
        }
    }

    // .opentelemetry.proto.metrics.v1.Sum sum = 7;


    pub fn get_sum(&self) -> &Sum {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::sum(ref v)) => v,
            _ => <Sum as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_sum(&mut self) {
        self.data = ::std::option::Option::None;
    }

    pub fn has_sum(&self) -> bool {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::sum(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_sum(&mut self, v: Sum) {
        self.data = ::std::option::Option::Some(Metric_oneof_data::sum(v))
    }

    // Mutable pointer to the field.
    pub fn mut_sum(&mut self) -> &mut Sum {
        if let ::std::option::Option::Some(Metric_oneof_data::sum(_)) = self.data {
        } else {
            self.data = ::std::option::Option::Some(Metric_oneof_data::sum(Sum::new()));
        }
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::sum(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_sum(&mut self) -> Sum {
        if self.has_sum() {
            match self.data.take() {
                ::std::option::Option::Some(Metric_oneof_data::sum(v)) => v,
                _ => panic!(),
            }
        } else {
            Sum::new()
        }
    }

    // .opentelemetry.proto.metrics.v1.IntHistogram int_histogram = 8;


    pub fn get_int_histogram(&self) -> &IntHistogram {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_histogram(ref v)) => v,
            _ => <IntHistogram as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_int_histogram(&mut self) {
        self.data = ::std::option::Option::None;
    }

    pub fn has_int_histogram(&self) -> bool {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_histogram(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int_histogram(&mut self, v: IntHistogram) {
        self.data = ::std::option::Option::Some(Metric_oneof_data::int_histogram(v))
    }

    // Mutable pointer to the field.
    pub fn mut_int_histogram(&mut self) -> &mut IntHistogram {
        if let ::std::option::Option::Some(Metric_oneof_data::int_histogram(_)) = self.data {
        } else {
            self.data = ::std::option::Option::Some(Metric_oneof_data::int_histogram(IntHistogram::new()));
        }
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::int_histogram(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_int_histogram(&mut self) -> IntHistogram {
        if self.has_int_histogram() {
            match self.data.take() {
                ::std::option::Option::Some(Metric_oneof_data::int_histogram(v)) => v,
                _ => panic!(),
            }
        } else {
            IntHistogram::new()
        }
    }

    // .opentelemetry.proto.metrics.v1.Histogram histogram = 9;


    pub fn get_histogram(&self) -> &Histogram {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::histogram(ref v)) => v,
            _ => <Histogram as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_histogram(&mut self) {
        self.data = ::std::option::Option::None;
    }

    pub fn has_histogram(&self) -> bool {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::histogram(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_histogram(&mut self, v: Histogram) {
        self.data = ::std::option::Option::Some(Metric_oneof_data::histogram(v))
    }

    // Mutable pointer to the field.
    pub fn mut_histogram(&mut self) -> &mut Histogram {
        if let ::std::option::Option::Some(Metric_oneof_data::histogram(_)) = self.data {
        } else {
            self.data = ::std::option::Option::Some(Metric_oneof_data::histogram(Histogram::new()));
        }
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::histogram(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_histogram(&mut self) -> Histogram {
        if self.has_histogram() {
            match self.data.take() {
                ::std::option::Option::Some(Metric_oneof_data::histogram(v)) => v,
                _ => panic!(),
            }
        } else {
            Histogram::new()
        }
    }

    // .opentelemetry.proto.metrics.v1.Summary summary = 11;


    pub fn get_summary(&self) -> &Summary {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::summary(ref v)) => v,
            _ => <Summary as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_summary(&mut self) {
        self.data = ::std::option::Option::None;
    }

    pub fn has_summary(&self) -> bool {
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::summary(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_summary(&mut self, v: Summary) {
        self.data = ::std::option::Option::Some(Metric_oneof_data::summary(v))
    }

    // Mutable pointer to the field.
    pub fn mut_summary(&mut self) -> &mut Summary {
        if let ::std::option::Option::Some(Metric_oneof_data::summary(_)) = self.data {
        } else {
            self.data = ::std::option::Option::Some(Metric_oneof_data::summary(Summary::new()));
        }
        match self.data {
            ::std::option::Option::Some(Metric_oneof_data::summary(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_summary(&mut self) -> Summary {
        if self.has_summary() {
            match self.data.take() {
                ::std::option::Option::Some(Metric_oneof_data::summary(v)) => v,
                _ => panic!(),
            }
        } else {
            Summary::new()
        }
    }
}

impl ::protobuf::Message for Metric {
    fn is_initialized(&self) -> bool {
        if let Some(Metric_oneof_data::int_gauge(ref v)) = self.data {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Metric_oneof_data::gauge(ref v)) = self.data {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Metric_oneof_data::int_sum(ref v)) = self.data {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Metric_oneof_data::sum(ref v)) = self.data {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Metric_oneof_data::int_histogram(ref v)) = self.data {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Metric_oneof_data::histogram(ref v)) = self.data {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Metric_oneof_data::summary(ref v)) = self.data {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.unit)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.data = ::std::option::Option::Some(Metric_oneof_data::int_gauge(is.read_message()?));
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.data = ::std::option::Option::Some(Metric_oneof_data::gauge(is.read_message()?));
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.data = ::std::option::Option::Some(Metric_oneof_data::int_sum(is.read_message()?));
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.data = ::std::option::Option::Some(Metric_oneof_data::sum(is.read_message()?));
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.data = ::std::option::Option::Some(Metric_oneof_data::int_histogram(is.read_message()?));
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.data = ::std::option::Option::Some(Metric_oneof_data::histogram(is.read_message()?));
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.data = ::std::option::Option::Some(Metric_oneof_data::summary(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if !self.description.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.description);
        }
        if !self.unit.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.unit);
        }
        if let ::std::option::Option::Some(ref v) = self.data {
            match v {
                &Metric_oneof_data::int_gauge(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Metric_oneof_data::gauge(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Metric_oneof_data::int_sum(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Metric_oneof_data::sum(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Metric_oneof_data::int_histogram(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Metric_oneof_data::histogram(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Metric_oneof_data::summary(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if !self.description.is_empty() {
            os.write_string(2, &self.description)?;
        }
        if !self.unit.is_empty() {
            os.write_string(3, &self.unit)?;
        }
        if let ::std::option::Option::Some(ref v) = self.data {
            match v {
                &Metric_oneof_data::int_gauge(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Metric_oneof_data::gauge(ref v) => {
                    os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Metric_oneof_data::int_sum(ref v) => {
                    os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Metric_oneof_data::sum(ref v) => {
                    os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Metric_oneof_data::int_histogram(ref v) => {
                    os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Metric_oneof_data::histogram(ref v) => {
                    os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Metric_oneof_data::summary(ref v) => {
                    os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Metric {
        Metric::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &Metric| { &m.name },
                |m: &mut Metric| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "description",
                |m: &Metric| { &m.description },
                |m: &mut Metric| { &mut m.description },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "unit",
                |m: &Metric| { &m.unit },
                |m: &mut Metric| { &mut m.unit },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, IntGauge>(
                "int_gauge",
                Metric::has_int_gauge,
                Metric::get_int_gauge,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Gauge>(
                "gauge",
                Metric::has_gauge,
                Metric::get_gauge,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, IntSum>(
                "int_sum",
                Metric::has_int_sum,
                Metric::get_int_sum,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Sum>(
                "sum",
                Metric::has_sum,
                Metric::get_sum,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, IntHistogram>(
                "int_histogram",
                Metric::has_int_histogram,
                Metric::get_int_histogram,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Histogram>(
                "histogram",
                Metric::has_histogram,
                Metric::get_histogram,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Summary>(
                "summary",
                Metric::has_summary,
                Metric::get_summary,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Metric>(
                "Metric",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Metric {
        static instance: ::protobuf::rt::LazyV2<Metric> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Metric::new)
    }
}

impl ::protobuf::Clear for Metric {
    fn clear(&mut self) {
        self.name.clear();
        self.description.clear();
        self.unit.clear();
        self.data = ::std::option::Option::None;
        self.data = ::std::option::Option::None;
        self.data = ::std::option::Option::None;
        self.data = ::std::option::Option::None;
        self.data = ::std::option::Option::None;
        self.data = ::std::option::Option::None;
        self.data = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Metric {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Metric {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct IntGauge {
    // message fields
    pub data_points: ::protobuf::RepeatedField<IntDataPoint>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a IntGauge {
    fn default() -> &'a IntGauge {
        <IntGauge as ::protobuf::Message>::default_instance()
    }
}

impl IntGauge {
    pub fn new() -> IntGauge {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.metrics.v1.IntDataPoint data_points = 1;


    pub fn get_data_points(&self) -> &[IntDataPoint] {
        &self.data_points
    }
    pub fn clear_data_points(&mut self) {
        self.data_points.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_points(&mut self, v: ::protobuf::RepeatedField<IntDataPoint>) {
        self.data_points = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_points(&mut self) -> &mut ::protobuf::RepeatedField<IntDataPoint> {
        &mut self.data_points
    }

    // Take field
    pub fn take_data_points(&mut self) -> ::protobuf::RepeatedField<IntDataPoint> {
        ::std::mem::replace(&mut self.data_points, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for IntGauge {
    fn is_initialized(&self) -> bool {
        for v in &self.data_points {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.data_points)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.data_points {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.data_points {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> IntGauge {
        IntGauge::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<IntDataPoint>>(
                "data_points",
                |m: &IntGauge| { &m.data_points },
                |m: &mut IntGauge| { &mut m.data_points },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<IntGauge>(
                "IntGauge",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static IntGauge {
        static instance: ::protobuf::rt::LazyV2<IntGauge> = ::protobuf::rt::LazyV2::INIT;
        instance.get(IntGauge::new)
    }
}

impl ::protobuf::Clear for IntGauge {
    fn clear(&mut self) {
        self.data_points.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for IntGauge {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for IntGauge {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct Gauge {
    // message fields
    pub data_points: ::protobuf::RepeatedField<NumberDataPoint>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Gauge {
    fn default() -> &'a Gauge {
        <Gauge as ::protobuf::Message>::default_instance()
    }
}

impl Gauge {
    pub fn new() -> Gauge {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.metrics.v1.NumberDataPoint data_points = 1;


    pub fn get_data_points(&self) -> &[NumberDataPoint] {
        &self.data_points
    }
    pub fn clear_data_points(&mut self) {
        self.data_points.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_points(&mut self, v: ::protobuf::RepeatedField<NumberDataPoint>) {
        self.data_points = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_points(&mut self) -> &mut ::protobuf::RepeatedField<NumberDataPoint> {
        &mut self.data_points
    }

    // Take field
    pub fn take_data_points(&mut self) -> ::protobuf::RepeatedField<NumberDataPoint> {
        ::std::mem::replace(&mut self.data_points, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for Gauge {
    fn is_initialized(&self) -> bool {
        for v in &self.data_points {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.data_points)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.data_points {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.data_points {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Gauge {
        Gauge::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NumberDataPoint>>(
                "data_points",
                |m: &Gauge| { &m.data_points },
                |m: &mut Gauge| { &mut m.data_points },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Gauge>(
                "Gauge",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Gauge {
        static instance: ::protobuf::rt::LazyV2<Gauge> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Gauge::new)
    }
}

impl ::protobuf::Clear for Gauge {
    fn clear(&mut self) {
        self.data_points.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Gauge {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Gauge {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct IntSum {
    // message fields
    pub data_points: ::protobuf::RepeatedField<IntDataPoint>,
    pub aggregation_temporality: AggregationTemporality,
    pub is_monotonic: bool,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a IntSum {
    fn default() -> &'a IntSum {
        <IntSum as ::protobuf::Message>::default_instance()
    }
}

impl IntSum {
    pub fn new() -> IntSum {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.metrics.v1.IntDataPoint data_points = 1;


    pub fn get_data_points(&self) -> &[IntDataPoint] {
        &self.data_points
    }
    pub fn clear_data_points(&mut self) {
        self.data_points.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_points(&mut self, v: ::protobuf::RepeatedField<IntDataPoint>) {
        self.data_points = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_points(&mut self) -> &mut ::protobuf::RepeatedField<IntDataPoint> {
        &mut self.data_points
    }

    // Take field
    pub fn take_data_points(&mut self) -> ::protobuf::RepeatedField<IntDataPoint> {
        ::std::mem::replace(&mut self.data_points, ::protobuf::RepeatedField::new())
    }

    // .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2;


    pub fn get_aggregation_temporality(&self) -> AggregationTemporality {
        self.aggregation_temporality
    }
    pub fn clear_aggregation_temporality(&mut self) {
        self.aggregation_temporality = AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_aggregation_temporality(&mut self, v: AggregationTemporality) {
        self.aggregation_temporality = v;
    }

    // bool is_monotonic = 3;


    pub fn get_is_monotonic(&self) -> bool {
        self.is_monotonic
    }
    pub fn clear_is_monotonic(&mut self) {
        self.is_monotonic = false;
    }

    // Param is passed by value, moved
    pub fn set_is_monotonic(&mut self, v: bool) {
        self.is_monotonic = v;
    }
}

impl ::protobuf::Message for IntSum {
    fn is_initialized(&self) -> bool {
        for v in &self.data_points {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.data_points)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.aggregation_temporality, 2, &mut self.unknown_fields)?
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_monotonic = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.data_points {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.aggregation_temporality != AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.aggregation_temporality);
        }
        if self.is_monotonic != false {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.data_points {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.aggregation_temporality != AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.aggregation_temporality))?;
        }
        if self.is_monotonic != false {
            os.write_bool(3, self.is_monotonic)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> IntSum {
        IntSum::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<IntDataPoint>>(
                "data_points",
                |m: &IntSum| { &m.data_points },
                |m: &mut IntSum| { &mut m.data_points },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<AggregationTemporality>>(
                "aggregation_temporality",
                |m: &IntSum| { &m.aggregation_temporality },
                |m: &mut IntSum| { &mut m.aggregation_temporality },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_monotonic",
                |m: &IntSum| { &m.is_monotonic },
                |m: &mut IntSum| { &mut m.is_monotonic },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<IntSum>(
                "IntSum",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static IntSum {
        static instance: ::protobuf::rt::LazyV2<IntSum> = ::protobuf::rt::LazyV2::INIT;
        instance.get(IntSum::new)
    }
}

impl ::protobuf::Clear for IntSum {
    fn clear(&mut self) {
        self.data_points.clear();
        self.aggregation_temporality = AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED;
        self.is_monotonic = false;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for IntSum {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for IntSum {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct Sum {
    // message fields
    pub data_points: ::protobuf::RepeatedField<NumberDataPoint>,
    pub aggregation_temporality: AggregationTemporality,
    pub is_monotonic: bool,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Sum {
    fn default() -> &'a Sum {
        <Sum as ::protobuf::Message>::default_instance()
    }
}

impl Sum {
    pub fn new() -> Sum {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.metrics.v1.NumberDataPoint data_points = 1;


    pub fn get_data_points(&self) -> &[NumberDataPoint] {
        &self.data_points
    }
    pub fn clear_data_points(&mut self) {
        self.data_points.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_points(&mut self, v: ::protobuf::RepeatedField<NumberDataPoint>) {
        self.data_points = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_points(&mut self) -> &mut ::protobuf::RepeatedField<NumberDataPoint> {
        &mut self.data_points
    }

    // Take field
    pub fn take_data_points(&mut self) -> ::protobuf::RepeatedField<NumberDataPoint> {
        ::std::mem::replace(&mut self.data_points, ::protobuf::RepeatedField::new())
    }

    // .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2;


    pub fn get_aggregation_temporality(&self) -> AggregationTemporality {
        self.aggregation_temporality
    }
    pub fn clear_aggregation_temporality(&mut self) {
        self.aggregation_temporality = AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_aggregation_temporality(&mut self, v: AggregationTemporality) {
        self.aggregation_temporality = v;
    }

    // bool is_monotonic = 3;


    pub fn get_is_monotonic(&self) -> bool {
        self.is_monotonic
    }
    pub fn clear_is_monotonic(&mut self) {
        self.is_monotonic = false;
    }

    // Param is passed by value, moved
    pub fn set_is_monotonic(&mut self, v: bool) {
        self.is_monotonic = v;
    }
}

impl ::protobuf::Message for Sum {
    fn is_initialized(&self) -> bool {
        for v in &self.data_points {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.data_points)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.aggregation_temporality, 2, &mut self.unknown_fields)?
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_monotonic = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.data_points {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.aggregation_temporality != AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.aggregation_temporality);
        }
        if self.is_monotonic != false {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.data_points {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.aggregation_temporality != AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.aggregation_temporality))?;
        }
        if self.is_monotonic != false {
            os.write_bool(3, self.is_monotonic)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Sum {
        Sum::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NumberDataPoint>>(
                "data_points",
                |m: &Sum| { &m.data_points },
                |m: &mut Sum| { &mut m.data_points },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<AggregationTemporality>>(
                "aggregation_temporality",
                |m: &Sum| { &m.aggregation_temporality },
                |m: &mut Sum| { &mut m.aggregation_temporality },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_monotonic",
                |m: &Sum| { &m.is_monotonic },
                |m: &mut Sum| { &mut m.is_monotonic },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Sum>(
                "Sum",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Sum {
        static instance: ::protobuf::rt::LazyV2<Sum> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Sum::new)
    }
}

impl ::protobuf::Clear for Sum {
    fn clear(&mut self) {
        self.data_points.clear();
        self.aggregation_temporality = AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED;
        self.is_monotonic = false;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Sum {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Sum {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct IntHistogram {
    // message fields
    pub data_points: ::protobuf::RepeatedField<IntHistogramDataPoint>,
    pub aggregation_temporality: AggregationTemporality,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a IntHistogram {
    fn default() -> &'a IntHistogram {
        <IntHistogram as ::protobuf::Message>::default_instance()
    }
}

impl IntHistogram {
    pub fn new() -> IntHistogram {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.metrics.v1.IntHistogramDataPoint data_points = 1;


    pub fn get_data_points(&self) -> &[IntHistogramDataPoint] {
        &self.data_points
    }
    pub fn clear_data_points(&mut self) {
        self.data_points.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_points(&mut self, v: ::protobuf::RepeatedField<IntHistogramDataPoint>) {
        self.data_points = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_points(&mut self) -> &mut ::protobuf::RepeatedField<IntHistogramDataPoint> {
        &mut self.data_points
    }

    // Take field
    pub fn take_data_points(&mut self) -> ::protobuf::RepeatedField<IntHistogramDataPoint> {
        ::std::mem::replace(&mut self.data_points, ::protobuf::RepeatedField::new())
    }

    // .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2;


    pub fn get_aggregation_temporality(&self) -> AggregationTemporality {
        self.aggregation_temporality
    }
    pub fn clear_aggregation_temporality(&mut self) {
        self.aggregation_temporality = AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_aggregation_temporality(&mut self, v: AggregationTemporality) {
        self.aggregation_temporality = v;
    }
}

impl ::protobuf::Message for IntHistogram {
    fn is_initialized(&self) -> bool {
        for v in &self.data_points {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.data_points)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.aggregation_temporality, 2, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.data_points {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.aggregation_temporality != AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.aggregation_temporality);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.data_points {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.aggregation_temporality != AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.aggregation_temporality))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> IntHistogram {
        IntHistogram::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<IntHistogramDataPoint>>(
                "data_points",
                |m: &IntHistogram| { &m.data_points },
                |m: &mut IntHistogram| { &mut m.data_points },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<AggregationTemporality>>(
                "aggregation_temporality",
                |m: &IntHistogram| { &m.aggregation_temporality },
                |m: &mut IntHistogram| { &mut m.aggregation_temporality },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<IntHistogram>(
                "IntHistogram",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static IntHistogram {
        static instance: ::protobuf::rt::LazyV2<IntHistogram> = ::protobuf::rt::LazyV2::INIT;
        instance.get(IntHistogram::new)
    }
}

impl ::protobuf::Clear for IntHistogram {
    fn clear(&mut self) {
        self.data_points.clear();
        self.aggregation_temporality = AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for IntHistogram {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for IntHistogram {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct Histogram {
    // message fields
    pub data_points: ::protobuf::RepeatedField<HistogramDataPoint>,
    pub aggregation_temporality: AggregationTemporality,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Histogram {
    fn default() -> &'a Histogram {
        <Histogram as ::protobuf::Message>::default_instance()
    }
}

impl Histogram {
    pub fn new() -> Histogram {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.metrics.v1.HistogramDataPoint data_points = 1;


    pub fn get_data_points(&self) -> &[HistogramDataPoint] {
        &self.data_points
    }
    pub fn clear_data_points(&mut self) {
        self.data_points.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_points(&mut self, v: ::protobuf::RepeatedField<HistogramDataPoint>) {
        self.data_points = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_points(&mut self) -> &mut ::protobuf::RepeatedField<HistogramDataPoint> {
        &mut self.data_points
    }

    // Take field
    pub fn take_data_points(&mut self) -> ::protobuf::RepeatedField<HistogramDataPoint> {
        ::std::mem::replace(&mut self.data_points, ::protobuf::RepeatedField::new())
    }

    // .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2;


    pub fn get_aggregation_temporality(&self) -> AggregationTemporality {
        self.aggregation_temporality
    }
    pub fn clear_aggregation_temporality(&mut self) {
        self.aggregation_temporality = AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_aggregation_temporality(&mut self, v: AggregationTemporality) {
        self.aggregation_temporality = v;
    }
}

impl ::protobuf::Message for Histogram {
    fn is_initialized(&self) -> bool {
        for v in &self.data_points {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.data_points)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.aggregation_temporality, 2, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.data_points {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.aggregation_temporality != AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.aggregation_temporality);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.data_points {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.aggregation_temporality != AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.aggregation_temporality))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Histogram {
        Histogram::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<HistogramDataPoint>>(
                "data_points",
                |m: &Histogram| { &m.data_points },
                |m: &mut Histogram| { &mut m.data_points },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<AggregationTemporality>>(
                "aggregation_temporality",
                |m: &Histogram| { &m.aggregation_temporality },
                |m: &mut Histogram| { &mut m.aggregation_temporality },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Histogram>(
                "Histogram",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Histogram {
        static instance: ::protobuf::rt::LazyV2<Histogram> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Histogram::new)
    }
}

impl ::protobuf::Clear for Histogram {
    fn clear(&mut self) {
        self.data_points.clear();
        self.aggregation_temporality = AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Histogram {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Histogram {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct Summary {
    // message fields
    pub data_points: ::protobuf::RepeatedField<SummaryDataPoint>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Summary {
    fn default() -> &'a Summary {
        <Summary as ::protobuf::Message>::default_instance()
    }
}

impl Summary {
    pub fn new() -> Summary {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.metrics.v1.SummaryDataPoint data_points = 1;


    pub fn get_data_points(&self) -> &[SummaryDataPoint] {
        &self.data_points
    }
    pub fn clear_data_points(&mut self) {
        self.data_points.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_points(&mut self, v: ::protobuf::RepeatedField<SummaryDataPoint>) {
        self.data_points = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_points(&mut self) -> &mut ::protobuf::RepeatedField<SummaryDataPoint> {
        &mut self.data_points
    }

    // Take field
    pub fn take_data_points(&mut self) -> ::protobuf::RepeatedField<SummaryDataPoint> {
        ::std::mem::replace(&mut self.data_points, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for Summary {
    fn is_initialized(&self) -> bool {
        for v in &self.data_points {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.data_points)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.data_points {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.data_points {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Summary {
        Summary::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SummaryDataPoint>>(
                "data_points",
                |m: &Summary| { &m.data_points },
                |m: &mut Summary| { &mut m.data_points },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Summary>(
                "Summary",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Summary {
        static instance: ::protobuf::rt::LazyV2<Summary> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Summary::new)
    }
}

impl ::protobuf::Clear for Summary {
    fn clear(&mut self) {
        self.data_points.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Summary {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Summary {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct IntDataPoint {
    // message fields
    pub labels: ::protobuf::RepeatedField<super::common::StringKeyValue>,
    pub start_time_unix_nano: u64,
    pub time_unix_nano: u64,
    pub value: i64,
    pub exemplars: ::protobuf::RepeatedField<IntExemplar>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a IntDataPoint {
    fn default() -> &'a IntDataPoint {
        <IntDataPoint as ::protobuf::Message>::default_instance()
    }
}

impl IntDataPoint {
    pub fn new() -> IntDataPoint {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1;


    pub fn get_labels(&self) -> &[super::common::StringKeyValue] {
        &self.labels
    }
    pub fn clear_labels(&mut self) {
        self.labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<super::common::StringKeyValue>) {
        self.labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<super::common::StringKeyValue> {
        &mut self.labels
    }

    // Take field
    pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<super::common::StringKeyValue> {
        ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new())
    }

    // fixed64 start_time_unix_nano = 2;


    pub fn get_start_time_unix_nano(&self) -> u64 {
        self.start_time_unix_nano
    }
    pub fn clear_start_time_unix_nano(&mut self) {
        self.start_time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_start_time_unix_nano(&mut self, v: u64) {
        self.start_time_unix_nano = v;
    }

    // fixed64 time_unix_nano = 3;


    pub fn get_time_unix_nano(&self) -> u64 {
        self.time_unix_nano
    }
    pub fn clear_time_unix_nano(&mut self) {
        self.time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_time_unix_nano(&mut self, v: u64) {
        self.time_unix_nano = v;
    }

    // sfixed64 value = 4;


    pub fn get_value(&self) -> i64 {
        self.value
    }
    pub fn clear_value(&mut self) {
        self.value = 0;
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: i64) {
        self.value = v;
    }

    // repeated .opentelemetry.proto.metrics.v1.IntExemplar exemplars = 5;


    pub fn get_exemplars(&self) -> &[IntExemplar] {
        &self.exemplars
    }
    pub fn clear_exemplars(&mut self) {
        self.exemplars.clear();
    }

    // Param is passed by value, moved
    pub fn set_exemplars(&mut self, v: ::protobuf::RepeatedField<IntExemplar>) {
        self.exemplars = v;
    }

    // Mutable pointer to the field.
    pub fn mut_exemplars(&mut self) -> &mut ::protobuf::RepeatedField<IntExemplar> {
        &mut self.exemplars
    }

    // Take field
    pub fn take_exemplars(&mut self) -> ::protobuf::RepeatedField<IntExemplar> {
        ::std::mem::replace(&mut self.exemplars, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for IntDataPoint {
    fn is_initialized(&self) -> bool {
        for v in &self.labels {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.exemplars {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.labels)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.start_time_unix_nano = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.time_unix_nano = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_sfixed64()?;
                    self.value = tmp;
                },
                5 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.exemplars)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.labels {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.start_time_unix_nano != 0 {
            my_size += 9;
        }
        if self.time_unix_nano != 0 {
            my_size += 9;
        }
        if self.value != 0 {
            my_size += 9;
        }
        for value in &self.exemplars {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.labels {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.start_time_unix_nano != 0 {
            os.write_fixed64(2, self.start_time_unix_nano)?;
        }
        if self.time_unix_nano != 0 {
            os.write_fixed64(3, self.time_unix_nano)?;
        }
        if self.value != 0 {
            os.write_sfixed64(4, self.value)?;
        }
        for v in &self.exemplars {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> IntDataPoint {
        IntDataPoint::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::StringKeyValue>>(
                "labels",
                |m: &IntDataPoint| { &m.labels },
                |m: &mut IntDataPoint| { &mut m.labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "start_time_unix_nano",
                |m: &IntDataPoint| { &m.start_time_unix_nano },
                |m: &mut IntDataPoint| { &mut m.start_time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "time_unix_nano",
                |m: &IntDataPoint| { &m.time_unix_nano },
                |m: &mut IntDataPoint| { &mut m.time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeSfixed64>(
                "value",
                |m: &IntDataPoint| { &m.value },
                |m: &mut IntDataPoint| { &mut m.value },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<IntExemplar>>(
                "exemplars",
                |m: &IntDataPoint| { &m.exemplars },
                |m: &mut IntDataPoint| { &mut m.exemplars },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<IntDataPoint>(
                "IntDataPoint",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static IntDataPoint {
        static instance: ::protobuf::rt::LazyV2<IntDataPoint> = ::protobuf::rt::LazyV2::INIT;
        instance.get(IntDataPoint::new)
    }
}

impl ::protobuf::Clear for IntDataPoint {
    fn clear(&mut self) {
        self.labels.clear();
        self.start_time_unix_nano = 0;
        self.time_unix_nano = 0;
        self.value = 0;
        self.exemplars.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for IntDataPoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for IntDataPoint {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct NumberDataPoint {
    // message fields
    pub attributes: ::protobuf::RepeatedField<super::common::KeyValue>,
    pub labels: ::protobuf::RepeatedField<super::common::StringKeyValue>,
    pub start_time_unix_nano: u64,
    pub time_unix_nano: u64,
    pub exemplars: ::protobuf::RepeatedField<Exemplar>,
    // message oneof groups
    pub value: ::std::option::Option<NumberDataPoint_oneof_value>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a NumberDataPoint {
    fn default() -> &'a NumberDataPoint {
        <NumberDataPoint as ::protobuf::Message>::default_instance()
    }
}

#[derive(Clone,PartialEq,Debug)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub enum NumberDataPoint_oneof_value {
    as_double(f64),
    as_int(i64),
}

impl NumberDataPoint {
    pub fn new() -> NumberDataPoint {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.common.v1.KeyValue attributes = 7;


    pub fn get_attributes(&self) -> &[super::common::KeyValue] {
        &self.attributes
    }
    pub fn clear_attributes(&mut self) {
        self.attributes.clear();
    }

    // Param is passed by value, moved
    pub fn set_attributes(&mut self, v: ::protobuf::RepeatedField<super::common::KeyValue>) {
        self.attributes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_attributes(&mut self) -> &mut ::protobuf::RepeatedField<super::common::KeyValue> {
        &mut self.attributes
    }

    // Take field
    pub fn take_attributes(&mut self) -> ::protobuf::RepeatedField<super::common::KeyValue> {
        ::std::mem::replace(&mut self.attributes, ::protobuf::RepeatedField::new())
    }

    // repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1;


    pub fn get_labels(&self) -> &[super::common::StringKeyValue] {
        &self.labels
    }
    pub fn clear_labels(&mut self) {
        self.labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<super::common::StringKeyValue>) {
        self.labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<super::common::StringKeyValue> {
        &mut self.labels
    }

    // Take field
    pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<super::common::StringKeyValue> {
        ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new())
    }

    // fixed64 start_time_unix_nano = 2;


    pub fn get_start_time_unix_nano(&self) -> u64 {
        self.start_time_unix_nano
    }
    pub fn clear_start_time_unix_nano(&mut self) {
        self.start_time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_start_time_unix_nano(&mut self, v: u64) {
        self.start_time_unix_nano = v;
    }

    // fixed64 time_unix_nano = 3;


    pub fn get_time_unix_nano(&self) -> u64 {
        self.time_unix_nano
    }
    pub fn clear_time_unix_nano(&mut self) {
        self.time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_time_unix_nano(&mut self, v: u64) {
        self.time_unix_nano = v;
    }

    // double as_double = 4;


    pub fn get_as_double(&self) -> f64 {
        match self.value {
            ::std::option::Option::Some(NumberDataPoint_oneof_value::as_double(v)) => v,
            _ => 0.,
        }
    }
    pub fn clear_as_double(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_as_double(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(NumberDataPoint_oneof_value::as_double(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_as_double(&mut self, v: f64) {
        self.value = ::std::option::Option::Some(NumberDataPoint_oneof_value::as_double(v))
    }

    // sfixed64 as_int = 6;


    pub fn get_as_int(&self) -> i64 {
        match self.value {
            ::std::option::Option::Some(NumberDataPoint_oneof_value::as_int(v)) => v,
            _ => 0,
        }
    }
    pub fn clear_as_int(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_as_int(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(NumberDataPoint_oneof_value::as_int(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_as_int(&mut self, v: i64) {
        self.value = ::std::option::Option::Some(NumberDataPoint_oneof_value::as_int(v))
    }

    // repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 5;


    pub fn get_exemplars(&self) -> &[Exemplar] {
        &self.exemplars
    }
    pub fn clear_exemplars(&mut self) {
        self.exemplars.clear();
    }

    // Param is passed by value, moved
    pub fn set_exemplars(&mut self, v: ::protobuf::RepeatedField<Exemplar>) {
        self.exemplars = v;
    }

    // Mutable pointer to the field.
    pub fn mut_exemplars(&mut self) -> &mut ::protobuf::RepeatedField<Exemplar> {
        &mut self.exemplars
    }

    // Take field
    pub fn take_exemplars(&mut self) -> ::protobuf::RepeatedField<Exemplar> {
        ::std::mem::replace(&mut self.exemplars, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for NumberDataPoint {
    fn is_initialized(&self) -> bool {
        for v in &self.attributes {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.labels {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.exemplars {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                7 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.attributes)?;
                },
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.labels)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.start_time_unix_nano = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.time_unix_nano = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(NumberDataPoint_oneof_value::as_double(is.read_double()?));
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(NumberDataPoint_oneof_value::as_int(is.read_sfixed64()?));
                },
                5 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.exemplars)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.attributes {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.labels {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.start_time_unix_nano != 0 {
            my_size += 9;
        }
        if self.time_unix_nano != 0 {
            my_size += 9;
        }
        for value in &self.exemplars {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let ::std::option::Option::Some(ref v) = self.value {
            match v {
                &NumberDataPoint_oneof_value::as_double(v) => {
                    my_size += 9;
                },
                &NumberDataPoint_oneof_value::as_int(v) => {
                    my_size += 9;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.attributes {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.labels {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.start_time_unix_nano != 0 {
            os.write_fixed64(2, self.start_time_unix_nano)?;
        }
        if self.time_unix_nano != 0 {
            os.write_fixed64(3, self.time_unix_nano)?;
        }
        for v in &self.exemplars {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let ::std::option::Option::Some(ref v) = self.value {
            match v {
                &NumberDataPoint_oneof_value::as_double(v) => {
                    os.write_double(4, v)?;
                },
                &NumberDataPoint_oneof_value::as_int(v) => {
                    os.write_sfixed64(6, v)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> NumberDataPoint {
        NumberDataPoint::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::KeyValue>>(
                "attributes",
                |m: &NumberDataPoint| { &m.attributes },
                |m: &mut NumberDataPoint| { &mut m.attributes },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::StringKeyValue>>(
                "labels",
                |m: &NumberDataPoint| { &m.labels },
                |m: &mut NumberDataPoint| { &mut m.labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "start_time_unix_nano",
                |m: &NumberDataPoint| { &m.start_time_unix_nano },
                |m: &mut NumberDataPoint| { &mut m.start_time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "time_unix_nano",
                |m: &NumberDataPoint| { &m.time_unix_nano },
                |m: &mut NumberDataPoint| { &mut m.time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>(
                "as_double",
                NumberDataPoint::has_as_double,
                NumberDataPoint::get_as_double,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
                "as_int",
                NumberDataPoint::has_as_int,
                NumberDataPoint::get_as_int,
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Exemplar>>(
                "exemplars",
                |m: &NumberDataPoint| { &m.exemplars },
                |m: &mut NumberDataPoint| { &mut m.exemplars },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<NumberDataPoint>(
                "NumberDataPoint",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static NumberDataPoint {
        static instance: ::protobuf::rt::LazyV2<NumberDataPoint> = ::protobuf::rt::LazyV2::INIT;
        instance.get(NumberDataPoint::new)
    }
}

impl ::protobuf::Clear for NumberDataPoint {
    fn clear(&mut self) {
        self.attributes.clear();
        self.labels.clear();
        self.start_time_unix_nano = 0;
        self.time_unix_nano = 0;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.exemplars.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for NumberDataPoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for NumberDataPoint {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct IntHistogramDataPoint {
    // message fields
    pub labels: ::protobuf::RepeatedField<super::common::StringKeyValue>,
    pub start_time_unix_nano: u64,
    pub time_unix_nano: u64,
    pub count: u64,
    pub sum: i64,
    pub bucket_counts: ::std::vec::Vec<u64>,
    pub explicit_bounds: ::std::vec::Vec<f64>,
    pub exemplars: ::protobuf::RepeatedField<IntExemplar>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a IntHistogramDataPoint {
    fn default() -> &'a IntHistogramDataPoint {
        <IntHistogramDataPoint as ::protobuf::Message>::default_instance()
    }
}

impl IntHistogramDataPoint {
    pub fn new() -> IntHistogramDataPoint {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1;


    pub fn get_labels(&self) -> &[super::common::StringKeyValue] {
        &self.labels
    }
    pub fn clear_labels(&mut self) {
        self.labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<super::common::StringKeyValue>) {
        self.labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<super::common::StringKeyValue> {
        &mut self.labels
    }

    // Take field
    pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<super::common::StringKeyValue> {
        ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new())
    }

    // fixed64 start_time_unix_nano = 2;


    pub fn get_start_time_unix_nano(&self) -> u64 {
        self.start_time_unix_nano
    }
    pub fn clear_start_time_unix_nano(&mut self) {
        self.start_time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_start_time_unix_nano(&mut self, v: u64) {
        self.start_time_unix_nano = v;
    }

    // fixed64 time_unix_nano = 3;


    pub fn get_time_unix_nano(&self) -> u64 {
        self.time_unix_nano
    }
    pub fn clear_time_unix_nano(&mut self) {
        self.time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_time_unix_nano(&mut self, v: u64) {
        self.time_unix_nano = v;
    }

    // fixed64 count = 4;


    pub fn get_count(&self) -> u64 {
        self.count
    }
    pub fn clear_count(&mut self) {
        self.count = 0;
    }

    // Param is passed by value, moved
    pub fn set_count(&mut self, v: u64) {
        self.count = v;
    }

    // sfixed64 sum = 5;


    pub fn get_sum(&self) -> i64 {
        self.sum
    }
    pub fn clear_sum(&mut self) {
        self.sum = 0;
    }

    // Param is passed by value, moved
    pub fn set_sum(&mut self, v: i64) {
        self.sum = v;
    }

    // repeated fixed64 bucket_counts = 6;


    pub fn get_bucket_counts(&self) -> &[u64] {
        &self.bucket_counts
    }
    pub fn clear_bucket_counts(&mut self) {
        self.bucket_counts.clear();
    }

    // Param is passed by value, moved
    pub fn set_bucket_counts(&mut self, v: ::std::vec::Vec<u64>) {
        self.bucket_counts = v;
    }

    // Mutable pointer to the field.
    pub fn mut_bucket_counts(&mut self) -> &mut ::std::vec::Vec<u64> {
        &mut self.bucket_counts
    }

    // Take field
    pub fn take_bucket_counts(&mut self) -> ::std::vec::Vec<u64> {
        ::std::mem::replace(&mut self.bucket_counts, ::std::vec::Vec::new())
    }

    // repeated double explicit_bounds = 7;


    pub fn get_explicit_bounds(&self) -> &[f64] {
        &self.explicit_bounds
    }
    pub fn clear_explicit_bounds(&mut self) {
        self.explicit_bounds.clear();
    }

    // Param is passed by value, moved
    pub fn set_explicit_bounds(&mut self, v: ::std::vec::Vec<f64>) {
        self.explicit_bounds = v;
    }

    // Mutable pointer to the field.
    pub fn mut_explicit_bounds(&mut self) -> &mut ::std::vec::Vec<f64> {
        &mut self.explicit_bounds
    }

    // Take field
    pub fn take_explicit_bounds(&mut self) -> ::std::vec::Vec<f64> {
        ::std::mem::replace(&mut self.explicit_bounds, ::std::vec::Vec::new())
    }

    // repeated .opentelemetry.proto.metrics.v1.IntExemplar exemplars = 8;


    pub fn get_exemplars(&self) -> &[IntExemplar] {
        &self.exemplars
    }
    pub fn clear_exemplars(&mut self) {
        self.exemplars.clear();
    }

    // Param is passed by value, moved
    pub fn set_exemplars(&mut self, v: ::protobuf::RepeatedField<IntExemplar>) {
        self.exemplars = v;
    }

    // Mutable pointer to the field.
    pub fn mut_exemplars(&mut self) -> &mut ::protobuf::RepeatedField<IntExemplar> {
        &mut self.exemplars
    }

    // Take field
    pub fn take_exemplars(&mut self) -> ::protobuf::RepeatedField<IntExemplar> {
        ::std::mem::replace(&mut self.exemplars, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for IntHistogramDataPoint {
    fn is_initialized(&self) -> bool {
        for v in &self.labels {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.exemplars {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.labels)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.start_time_unix_nano = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.time_unix_nano = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.count = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_sfixed64()?;
                    self.sum = tmp;
                },
                6 => {
                    ::protobuf::rt::read_repeated_fixed64_into(wire_type, is, &mut self.bucket_counts)?;
                },
                7 => {
                    ::protobuf::rt::read_repeated_double_into(wire_type, is, &mut self.explicit_bounds)?;
                },
                8 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.exemplars)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.labels {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.start_time_unix_nano != 0 {
            my_size += 9;
        }
        if self.time_unix_nano != 0 {
            my_size += 9;
        }
        if self.count != 0 {
            my_size += 9;
        }
        if self.sum != 0 {
            my_size += 9;
        }
        my_size += 9 * self.bucket_counts.len() as u32;
        my_size += 9 * self.explicit_bounds.len() as u32;
        for value in &self.exemplars {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.labels {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.start_time_unix_nano != 0 {
            os.write_fixed64(2, self.start_time_unix_nano)?;
        }
        if self.time_unix_nano != 0 {
            os.write_fixed64(3, self.time_unix_nano)?;
        }
        if self.count != 0 {
            os.write_fixed64(4, self.count)?;
        }
        if self.sum != 0 {
            os.write_sfixed64(5, self.sum)?;
        }
        for v in &self.bucket_counts {
            os.write_fixed64(6, *v)?;
        };
        for v in &self.explicit_bounds {
            os.write_double(7, *v)?;
        };
        for v in &self.exemplars {
            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> IntHistogramDataPoint {
        IntHistogramDataPoint::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::StringKeyValue>>(
                "labels",
                |m: &IntHistogramDataPoint| { &m.labels },
                |m: &mut IntHistogramDataPoint| { &mut m.labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "start_time_unix_nano",
                |m: &IntHistogramDataPoint| { &m.start_time_unix_nano },
                |m: &mut IntHistogramDataPoint| { &mut m.start_time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "time_unix_nano",
                |m: &IntHistogramDataPoint| { &m.time_unix_nano },
                |m: &mut IntHistogramDataPoint| { &mut m.time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "count",
                |m: &IntHistogramDataPoint| { &m.count },
                |m: &mut IntHistogramDataPoint| { &mut m.count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeSfixed64>(
                "sum",
                |m: &IntHistogramDataPoint| { &m.sum },
                |m: &mut IntHistogramDataPoint| { &mut m.sum },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "bucket_counts",
                |m: &IntHistogramDataPoint| { &m.bucket_counts },
                |m: &mut IntHistogramDataPoint| { &mut m.bucket_counts },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "explicit_bounds",
                |m: &IntHistogramDataPoint| { &m.explicit_bounds },
                |m: &mut IntHistogramDataPoint| { &mut m.explicit_bounds },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<IntExemplar>>(
                "exemplars",
                |m: &IntHistogramDataPoint| { &m.exemplars },
                |m: &mut IntHistogramDataPoint| { &mut m.exemplars },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<IntHistogramDataPoint>(
                "IntHistogramDataPoint",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static IntHistogramDataPoint {
        static instance: ::protobuf::rt::LazyV2<IntHistogramDataPoint> = ::protobuf::rt::LazyV2::INIT;
        instance.get(IntHistogramDataPoint::new)
    }
}

impl ::protobuf::Clear for IntHistogramDataPoint {
    fn clear(&mut self) {
        self.labels.clear();
        self.start_time_unix_nano = 0;
        self.time_unix_nano = 0;
        self.count = 0;
        self.sum = 0;
        self.bucket_counts.clear();
        self.explicit_bounds.clear();
        self.exemplars.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for IntHistogramDataPoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for IntHistogramDataPoint {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct HistogramDataPoint {
    // message fields
    pub attributes: ::protobuf::RepeatedField<super::common::KeyValue>,
    pub labels: ::protobuf::RepeatedField<super::common::StringKeyValue>,
    pub start_time_unix_nano: u64,
    pub time_unix_nano: u64,
    pub count: u64,
    pub sum: f64,
    pub bucket_counts: ::std::vec::Vec<u64>,
    pub explicit_bounds: ::std::vec::Vec<f64>,
    pub exemplars: ::protobuf::RepeatedField<Exemplar>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a HistogramDataPoint {
    fn default() -> &'a HistogramDataPoint {
        <HistogramDataPoint as ::protobuf::Message>::default_instance()
    }
}

impl HistogramDataPoint {
    pub fn new() -> HistogramDataPoint {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.common.v1.KeyValue attributes = 9;


    pub fn get_attributes(&self) -> &[super::common::KeyValue] {
        &self.attributes
    }
    pub fn clear_attributes(&mut self) {
        self.attributes.clear();
    }

    // Param is passed by value, moved
    pub fn set_attributes(&mut self, v: ::protobuf::RepeatedField<super::common::KeyValue>) {
        self.attributes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_attributes(&mut self) -> &mut ::protobuf::RepeatedField<super::common::KeyValue> {
        &mut self.attributes
    }

    // Take field
    pub fn take_attributes(&mut self) -> ::protobuf::RepeatedField<super::common::KeyValue> {
        ::std::mem::replace(&mut self.attributes, ::protobuf::RepeatedField::new())
    }

    // repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1;


    pub fn get_labels(&self) -> &[super::common::StringKeyValue] {
        &self.labels
    }
    pub fn clear_labels(&mut self) {
        self.labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<super::common::StringKeyValue>) {
        self.labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<super::common::StringKeyValue> {
        &mut self.labels
    }

    // Take field
    pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<super::common::StringKeyValue> {
        ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new())
    }

    // fixed64 start_time_unix_nano = 2;


    pub fn get_start_time_unix_nano(&self) -> u64 {
        self.start_time_unix_nano
    }
    pub fn clear_start_time_unix_nano(&mut self) {
        self.start_time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_start_time_unix_nano(&mut self, v: u64) {
        self.start_time_unix_nano = v;
    }

    // fixed64 time_unix_nano = 3;


    pub fn get_time_unix_nano(&self) -> u64 {
        self.time_unix_nano
    }
    pub fn clear_time_unix_nano(&mut self) {
        self.time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_time_unix_nano(&mut self, v: u64) {
        self.time_unix_nano = v;
    }

    // fixed64 count = 4;


    pub fn get_count(&self) -> u64 {
        self.count
    }
    pub fn clear_count(&mut self) {
        self.count = 0;
    }

    // Param is passed by value, moved
    pub fn set_count(&mut self, v: u64) {
        self.count = v;
    }

    // double sum = 5;


    pub fn get_sum(&self) -> f64 {
        self.sum
    }
    pub fn clear_sum(&mut self) {
        self.sum = 0.;
    }

    // Param is passed by value, moved
    pub fn set_sum(&mut self, v: f64) {
        self.sum = v;
    }

    // repeated fixed64 bucket_counts = 6;


    pub fn get_bucket_counts(&self) -> &[u64] {
        &self.bucket_counts
    }
    pub fn clear_bucket_counts(&mut self) {
        self.bucket_counts.clear();
    }

    // Param is passed by value, moved
    pub fn set_bucket_counts(&mut self, v: ::std::vec::Vec<u64>) {
        self.bucket_counts = v;
    }

    // Mutable pointer to the field.
    pub fn mut_bucket_counts(&mut self) -> &mut ::std::vec::Vec<u64> {
        &mut self.bucket_counts
    }

    // Take field
    pub fn take_bucket_counts(&mut self) -> ::std::vec::Vec<u64> {
        ::std::mem::replace(&mut self.bucket_counts, ::std::vec::Vec::new())
    }

    // repeated double explicit_bounds = 7;


    pub fn get_explicit_bounds(&self) -> &[f64] {
        &self.explicit_bounds
    }
    pub fn clear_explicit_bounds(&mut self) {
        self.explicit_bounds.clear();
    }

    // Param is passed by value, moved
    pub fn set_explicit_bounds(&mut self, v: ::std::vec::Vec<f64>) {
        self.explicit_bounds = v;
    }

    // Mutable pointer to the field.
    pub fn mut_explicit_bounds(&mut self) -> &mut ::std::vec::Vec<f64> {
        &mut self.explicit_bounds
    }

    // Take field
    pub fn take_explicit_bounds(&mut self) -> ::std::vec::Vec<f64> {
        ::std::mem::replace(&mut self.explicit_bounds, ::std::vec::Vec::new())
    }

    // repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 8;


    pub fn get_exemplars(&self) -> &[Exemplar] {
        &self.exemplars
    }
    pub fn clear_exemplars(&mut self) {
        self.exemplars.clear();
    }

    // Param is passed by value, moved
    pub fn set_exemplars(&mut self, v: ::protobuf::RepeatedField<Exemplar>) {
        self.exemplars = v;
    }

    // Mutable pointer to the field.
    pub fn mut_exemplars(&mut self) -> &mut ::protobuf::RepeatedField<Exemplar> {
        &mut self.exemplars
    }

    // Take field
    pub fn take_exemplars(&mut self) -> ::protobuf::RepeatedField<Exemplar> {
        ::std::mem::replace(&mut self.exemplars, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for HistogramDataPoint {
    fn is_initialized(&self) -> bool {
        for v in &self.attributes {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.labels {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.exemplars {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                9 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.attributes)?;
                },
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.labels)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.start_time_unix_nano = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.time_unix_nano = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.count = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_double()?;
                    self.sum = tmp;
                },
                6 => {
                    ::protobuf::rt::read_repeated_fixed64_into(wire_type, is, &mut self.bucket_counts)?;
                },
                7 => {
                    ::protobuf::rt::read_repeated_double_into(wire_type, is, &mut self.explicit_bounds)?;
                },
                8 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.exemplars)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.attributes {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.labels {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.start_time_unix_nano != 0 {
            my_size += 9;
        }
        if self.time_unix_nano != 0 {
            my_size += 9;
        }
        if self.count != 0 {
            my_size += 9;
        }
        if self.sum != 0. {
            my_size += 9;
        }
        my_size += 9 * self.bucket_counts.len() as u32;
        my_size += 9 * self.explicit_bounds.len() as u32;
        for value in &self.exemplars {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.attributes {
            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.labels {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.start_time_unix_nano != 0 {
            os.write_fixed64(2, self.start_time_unix_nano)?;
        }
        if self.time_unix_nano != 0 {
            os.write_fixed64(3, self.time_unix_nano)?;
        }
        if self.count != 0 {
            os.write_fixed64(4, self.count)?;
        }
        if self.sum != 0. {
            os.write_double(5, self.sum)?;
        }
        for v in &self.bucket_counts {
            os.write_fixed64(6, *v)?;
        };
        for v in &self.explicit_bounds {
            os.write_double(7, *v)?;
        };
        for v in &self.exemplars {
            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> HistogramDataPoint {
        HistogramDataPoint::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::KeyValue>>(
                "attributes",
                |m: &HistogramDataPoint| { &m.attributes },
                |m: &mut HistogramDataPoint| { &mut m.attributes },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::StringKeyValue>>(
                "labels",
                |m: &HistogramDataPoint| { &m.labels },
                |m: &mut HistogramDataPoint| { &mut m.labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "start_time_unix_nano",
                |m: &HistogramDataPoint| { &m.start_time_unix_nano },
                |m: &mut HistogramDataPoint| { &mut m.start_time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "time_unix_nano",
                |m: &HistogramDataPoint| { &m.time_unix_nano },
                |m: &mut HistogramDataPoint| { &mut m.time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "count",
                |m: &HistogramDataPoint| { &m.count },
                |m: &mut HistogramDataPoint| { &mut m.count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "sum",
                |m: &HistogramDataPoint| { &m.sum },
                |m: &mut HistogramDataPoint| { &mut m.sum },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "bucket_counts",
                |m: &HistogramDataPoint| { &m.bucket_counts },
                |m: &mut HistogramDataPoint| { &mut m.bucket_counts },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "explicit_bounds",
                |m: &HistogramDataPoint| { &m.explicit_bounds },
                |m: &mut HistogramDataPoint| { &mut m.explicit_bounds },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Exemplar>>(
                "exemplars",
                |m: &HistogramDataPoint| { &m.exemplars },
                |m: &mut HistogramDataPoint| { &mut m.exemplars },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<HistogramDataPoint>(
                "HistogramDataPoint",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static HistogramDataPoint {
        static instance: ::protobuf::rt::LazyV2<HistogramDataPoint> = ::protobuf::rt::LazyV2::INIT;
        instance.get(HistogramDataPoint::new)
    }
}

impl ::protobuf::Clear for HistogramDataPoint {
    fn clear(&mut self) {
        self.attributes.clear();
        self.labels.clear();
        self.start_time_unix_nano = 0;
        self.time_unix_nano = 0;
        self.count = 0;
        self.sum = 0.;
        self.bucket_counts.clear();
        self.explicit_bounds.clear();
        self.exemplars.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for HistogramDataPoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for HistogramDataPoint {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct SummaryDataPoint {
    // message fields
    pub attributes: ::protobuf::RepeatedField<super::common::KeyValue>,
    pub labels: ::protobuf::RepeatedField<super::common::StringKeyValue>,
    pub start_time_unix_nano: u64,
    pub time_unix_nano: u64,
    pub count: u64,
    pub sum: f64,
    pub quantile_values: ::protobuf::RepeatedField<SummaryDataPoint_ValueAtQuantile>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a SummaryDataPoint {
    fn default() -> &'a SummaryDataPoint {
        <SummaryDataPoint as ::protobuf::Message>::default_instance()
    }
}

impl SummaryDataPoint {
    pub fn new() -> SummaryDataPoint {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.common.v1.KeyValue attributes = 7;


    pub fn get_attributes(&self) -> &[super::common::KeyValue] {
        &self.attributes
    }
    pub fn clear_attributes(&mut self) {
        self.attributes.clear();
    }

    // Param is passed by value, moved
    pub fn set_attributes(&mut self, v: ::protobuf::RepeatedField<super::common::KeyValue>) {
        self.attributes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_attributes(&mut self) -> &mut ::protobuf::RepeatedField<super::common::KeyValue> {
        &mut self.attributes
    }

    // Take field
    pub fn take_attributes(&mut self) -> ::protobuf::RepeatedField<super::common::KeyValue> {
        ::std::mem::replace(&mut self.attributes, ::protobuf::RepeatedField::new())
    }

    // repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1;


    pub fn get_labels(&self) -> &[super::common::StringKeyValue] {
        &self.labels
    }
    pub fn clear_labels(&mut self) {
        self.labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<super::common::StringKeyValue>) {
        self.labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<super::common::StringKeyValue> {
        &mut self.labels
    }

    // Take field
    pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<super::common::StringKeyValue> {
        ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new())
    }

    // fixed64 start_time_unix_nano = 2;


    pub fn get_start_time_unix_nano(&self) -> u64 {
        self.start_time_unix_nano
    }
    pub fn clear_start_time_unix_nano(&mut self) {
        self.start_time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_start_time_unix_nano(&mut self, v: u64) {
        self.start_time_unix_nano = v;
    }

    // fixed64 time_unix_nano = 3;


    pub fn get_time_unix_nano(&self) -> u64 {
        self.time_unix_nano
    }
    pub fn clear_time_unix_nano(&mut self) {
        self.time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_time_unix_nano(&mut self, v: u64) {
        self.time_unix_nano = v;
    }

    // fixed64 count = 4;


    pub fn get_count(&self) -> u64 {
        self.count
    }
    pub fn clear_count(&mut self) {
        self.count = 0;
    }

    // Param is passed by value, moved
    pub fn set_count(&mut self, v: u64) {
        self.count = v;
    }

    // double sum = 5;


    pub fn get_sum(&self) -> f64 {
        self.sum
    }
    pub fn clear_sum(&mut self) {
        self.sum = 0.;
    }

    // Param is passed by value, moved
    pub fn set_sum(&mut self, v: f64) {
        self.sum = v;
    }

    // repeated .opentelemetry.proto.metrics.v1.SummaryDataPoint.ValueAtQuantile quantile_values = 6;


    pub fn get_quantile_values(&self) -> &[SummaryDataPoint_ValueAtQuantile] {
        &self.quantile_values
    }
    pub fn clear_quantile_values(&mut self) {
        self.quantile_values.clear();
    }

    // Param is passed by value, moved
    pub fn set_quantile_values(&mut self, v: ::protobuf::RepeatedField<SummaryDataPoint_ValueAtQuantile>) {
        self.quantile_values = v;
    }

    // Mutable pointer to the field.
    pub fn mut_quantile_values(&mut self) -> &mut ::protobuf::RepeatedField<SummaryDataPoint_ValueAtQuantile> {
        &mut self.quantile_values
    }

    // Take field
    pub fn take_quantile_values(&mut self) -> ::protobuf::RepeatedField<SummaryDataPoint_ValueAtQuantile> {
        ::std::mem::replace(&mut self.quantile_values, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for SummaryDataPoint {
    fn is_initialized(&self) -> bool {
        for v in &self.attributes {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.labels {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.quantile_values {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                7 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.attributes)?;
                },
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.labels)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.start_time_unix_nano = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.time_unix_nano = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.count = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_double()?;
                    self.sum = tmp;
                },
                6 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.quantile_values)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.attributes {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.labels {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.start_time_unix_nano != 0 {
            my_size += 9;
        }
        if self.time_unix_nano != 0 {
            my_size += 9;
        }
        if self.count != 0 {
            my_size += 9;
        }
        if self.sum != 0. {
            my_size += 9;
        }
        for value in &self.quantile_values {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.attributes {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.labels {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.start_time_unix_nano != 0 {
            os.write_fixed64(2, self.start_time_unix_nano)?;
        }
        if self.time_unix_nano != 0 {
            os.write_fixed64(3, self.time_unix_nano)?;
        }
        if self.count != 0 {
            os.write_fixed64(4, self.count)?;
        }
        if self.sum != 0. {
            os.write_double(5, self.sum)?;
        }
        for v in &self.quantile_values {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> SummaryDataPoint {
        SummaryDataPoint::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::KeyValue>>(
                "attributes",
                |m: &SummaryDataPoint| { &m.attributes },
                |m: &mut SummaryDataPoint| { &mut m.attributes },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::StringKeyValue>>(
                "labels",
                |m: &SummaryDataPoint| { &m.labels },
                |m: &mut SummaryDataPoint| { &mut m.labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "start_time_unix_nano",
                |m: &SummaryDataPoint| { &m.start_time_unix_nano },
                |m: &mut SummaryDataPoint| { &mut m.start_time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "time_unix_nano",
                |m: &SummaryDataPoint| { &m.time_unix_nano },
                |m: &mut SummaryDataPoint| { &mut m.time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "count",
                |m: &SummaryDataPoint| { &m.count },
                |m: &mut SummaryDataPoint| { &mut m.count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "sum",
                |m: &SummaryDataPoint| { &m.sum },
                |m: &mut SummaryDataPoint| { &mut m.sum },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SummaryDataPoint_ValueAtQuantile>>(
                "quantile_values",
                |m: &SummaryDataPoint| { &m.quantile_values },
                |m: &mut SummaryDataPoint| { &mut m.quantile_values },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SummaryDataPoint>(
                "SummaryDataPoint",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SummaryDataPoint {
        static instance: ::protobuf::rt::LazyV2<SummaryDataPoint> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SummaryDataPoint::new)
    }
}

impl ::protobuf::Clear for SummaryDataPoint {
    fn clear(&mut self) {
        self.attributes.clear();
        self.labels.clear();
        self.start_time_unix_nano = 0;
        self.time_unix_nano = 0;
        self.count = 0;
        self.sum = 0.;
        self.quantile_values.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for SummaryDataPoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for SummaryDataPoint {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct SummaryDataPoint_ValueAtQuantile {
    // message fields
    pub quantile: f64,
    pub value: f64,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a SummaryDataPoint_ValueAtQuantile {
    fn default() -> &'a SummaryDataPoint_ValueAtQuantile {
        <SummaryDataPoint_ValueAtQuantile as ::protobuf::Message>::default_instance()
    }
}

impl SummaryDataPoint_ValueAtQuantile {
    pub fn new() -> SummaryDataPoint_ValueAtQuantile {
        ::std::default::Default::default()
    }

    // double quantile = 1;


    pub fn get_quantile(&self) -> f64 {
        self.quantile
    }
    pub fn clear_quantile(&mut self) {
        self.quantile = 0.;
    }

    // Param is passed by value, moved
    pub fn set_quantile(&mut self, v: f64) {
        self.quantile = v;
    }

    // double value = 2;


    pub fn get_value(&self) -> f64 {
        self.value
    }
    pub fn clear_value(&mut self) {
        self.value = 0.;
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: f64) {
        self.value = v;
    }
}

impl ::protobuf::Message for SummaryDataPoint_ValueAtQuantile {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_double()?;
                    self.quantile = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_double()?;
                    self.value = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.quantile != 0. {
            my_size += 9;
        }
        if self.value != 0. {
            my_size += 9;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.quantile != 0. {
            os.write_double(1, self.quantile)?;
        }
        if self.value != 0. {
            os.write_double(2, self.value)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> SummaryDataPoint_ValueAtQuantile {
        SummaryDataPoint_ValueAtQuantile::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "quantile",
                |m: &SummaryDataPoint_ValueAtQuantile| { &m.quantile },
                |m: &mut SummaryDataPoint_ValueAtQuantile| { &mut m.quantile },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "value",
                |m: &SummaryDataPoint_ValueAtQuantile| { &m.value },
                |m: &mut SummaryDataPoint_ValueAtQuantile| { &mut m.value },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SummaryDataPoint_ValueAtQuantile>(
                "SummaryDataPoint.ValueAtQuantile",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SummaryDataPoint_ValueAtQuantile {
        static instance: ::protobuf::rt::LazyV2<SummaryDataPoint_ValueAtQuantile> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SummaryDataPoint_ValueAtQuantile::new)
    }
}

impl ::protobuf::Clear for SummaryDataPoint_ValueAtQuantile {
    fn clear(&mut self) {
        self.quantile = 0.;
        self.value = 0.;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for SummaryDataPoint_ValueAtQuantile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for SummaryDataPoint_ValueAtQuantile {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct IntExemplar {
    // message fields
    pub filtered_labels: ::protobuf::RepeatedField<super::common::StringKeyValue>,
    pub time_unix_nano: u64,
    pub value: i64,
    pub span_id: ::std::vec::Vec<u8>,
    pub trace_id: ::std::vec::Vec<u8>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a IntExemplar {
    fn default() -> &'a IntExemplar {
        <IntExemplar as ::protobuf::Message>::default_instance()
    }
}

impl IntExemplar {
    pub fn new() -> IntExemplar {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.common.v1.StringKeyValue filtered_labels = 1;


    pub fn get_filtered_labels(&self) -> &[super::common::StringKeyValue] {
        &self.filtered_labels
    }
    pub fn clear_filtered_labels(&mut self) {
        self.filtered_labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_filtered_labels(&mut self, v: ::protobuf::RepeatedField<super::common::StringKeyValue>) {
        self.filtered_labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_filtered_labels(&mut self) -> &mut ::protobuf::RepeatedField<super::common::StringKeyValue> {
        &mut self.filtered_labels
    }

    // Take field
    pub fn take_filtered_labels(&mut self) -> ::protobuf::RepeatedField<super::common::StringKeyValue> {
        ::std::mem::replace(&mut self.filtered_labels, ::protobuf::RepeatedField::new())
    }

    // fixed64 time_unix_nano = 2;


    pub fn get_time_unix_nano(&self) -> u64 {
        self.time_unix_nano
    }
    pub fn clear_time_unix_nano(&mut self) {
        self.time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_time_unix_nano(&mut self, v: u64) {
        self.time_unix_nano = v;
    }

    // sfixed64 value = 3;


    pub fn get_value(&self) -> i64 {
        self.value
    }
    pub fn clear_value(&mut self) {
        self.value = 0;
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: i64) {
        self.value = v;
    }

    // bytes span_id = 4;


    pub fn get_span_id(&self) -> &[u8] {
        &self.span_id
    }
    pub fn clear_span_id(&mut self) {
        self.span_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_span_id(&mut self, v: ::std::vec::Vec<u8>) {
        self.span_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_span_id(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.span_id
    }

    // Take field
    pub fn take_span_id(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.span_id, ::std::vec::Vec::new())
    }

    // bytes trace_id = 5;


    pub fn get_trace_id(&self) -> &[u8] {
        &self.trace_id
    }
    pub fn clear_trace_id(&mut self) {
        self.trace_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_trace_id(&mut self, v: ::std::vec::Vec<u8>) {
        self.trace_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_trace_id(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.trace_id
    }

    // Take field
    pub fn take_trace_id(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.trace_id, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for IntExemplar {
    fn is_initialized(&self) -> bool {
        for v in &self.filtered_labels {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.filtered_labels)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.time_unix_nano = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_sfixed64()?;
                    self.value = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.span_id)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.trace_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.filtered_labels {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.time_unix_nano != 0 {
            my_size += 9;
        }
        if self.value != 0 {
            my_size += 9;
        }
        if !self.span_id.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.span_id);
        }
        if !self.trace_id.is_empty() {
            my_size += ::protobuf::rt::bytes_size(5, &self.trace_id);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.filtered_labels {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.time_unix_nano != 0 {
            os.write_fixed64(2, self.time_unix_nano)?;
        }
        if self.value != 0 {
            os.write_sfixed64(3, self.value)?;
        }
        if !self.span_id.is_empty() {
            os.write_bytes(4, &self.span_id)?;
        }
        if !self.trace_id.is_empty() {
            os.write_bytes(5, &self.trace_id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> IntExemplar {
        IntExemplar::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::StringKeyValue>>(
                "filtered_labels",
                |m: &IntExemplar| { &m.filtered_labels },
                |m: &mut IntExemplar| { &mut m.filtered_labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "time_unix_nano",
                |m: &IntExemplar| { &m.time_unix_nano },
                |m: &mut IntExemplar| { &mut m.time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeSfixed64>(
                "value",
                |m: &IntExemplar| { &m.value },
                |m: &mut IntExemplar| { &mut m.value },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "span_id",
                |m: &IntExemplar| { &m.span_id },
                |m: &mut IntExemplar| { &mut m.span_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "trace_id",
                |m: &IntExemplar| { &m.trace_id },
                |m: &mut IntExemplar| { &mut m.trace_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<IntExemplar>(
                "IntExemplar",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static IntExemplar {
        static instance: ::protobuf::rt::LazyV2<IntExemplar> = ::protobuf::rt::LazyV2::INIT;
        instance.get(IntExemplar::new)
    }
}

impl ::protobuf::Clear for IntExemplar {
    fn clear(&mut self) {
        self.filtered_labels.clear();
        self.time_unix_nano = 0;
        self.value = 0;
        self.span_id.clear();
        self.trace_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for IntExemplar {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for IntExemplar {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct Exemplar {
    // message fields
    pub filtered_attributes: ::protobuf::RepeatedField<super::common::KeyValue>,
    pub filtered_labels: ::protobuf::RepeatedField<super::common::StringKeyValue>,
    pub time_unix_nano: u64,
    pub span_id: ::std::vec::Vec<u8>,
    pub trace_id: ::std::vec::Vec<u8>,
    // message oneof groups
    pub value: ::std::option::Option<Exemplar_oneof_value>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Exemplar {
    fn default() -> &'a Exemplar {
        <Exemplar as ::protobuf::Message>::default_instance()
    }
}

#[derive(Clone,PartialEq,Debug)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub enum Exemplar_oneof_value {
    as_double(f64),
    as_int(i64),
}

impl Exemplar {
    pub fn new() -> Exemplar {
        ::std::default::Default::default()
    }

    // repeated .opentelemetry.proto.common.v1.KeyValue filtered_attributes = 7;


    pub fn get_filtered_attributes(&self) -> &[super::common::KeyValue] {
        &self.filtered_attributes
    }
    pub fn clear_filtered_attributes(&mut self) {
        self.filtered_attributes.clear();
    }

    // Param is passed by value, moved
    pub fn set_filtered_attributes(&mut self, v: ::protobuf::RepeatedField<super::common::KeyValue>) {
        self.filtered_attributes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_filtered_attributes(&mut self) -> &mut ::protobuf::RepeatedField<super::common::KeyValue> {
        &mut self.filtered_attributes
    }

    // Take field
    pub fn take_filtered_attributes(&mut self) -> ::protobuf::RepeatedField<super::common::KeyValue> {
        ::std::mem::replace(&mut self.filtered_attributes, ::protobuf::RepeatedField::new())
    }

    // repeated .opentelemetry.proto.common.v1.StringKeyValue filtered_labels = 1;


    pub fn get_filtered_labels(&self) -> &[super::common::StringKeyValue] {
        &self.filtered_labels
    }
    pub fn clear_filtered_labels(&mut self) {
        self.filtered_labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_filtered_labels(&mut self, v: ::protobuf::RepeatedField<super::common::StringKeyValue>) {
        self.filtered_labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_filtered_labels(&mut self) -> &mut ::protobuf::RepeatedField<super::common::StringKeyValue> {
        &mut self.filtered_labels
    }

    // Take field
    pub fn take_filtered_labels(&mut self) -> ::protobuf::RepeatedField<super::common::StringKeyValue> {
        ::std::mem::replace(&mut self.filtered_labels, ::protobuf::RepeatedField::new())
    }

    // fixed64 time_unix_nano = 2;


    pub fn get_time_unix_nano(&self) -> u64 {
        self.time_unix_nano
    }
    pub fn clear_time_unix_nano(&mut self) {
        self.time_unix_nano = 0;
    }

    // Param is passed by value, moved
    pub fn set_time_unix_nano(&mut self, v: u64) {
        self.time_unix_nano = v;
    }

    // double as_double = 3;


    pub fn get_as_double(&self) -> f64 {
        match self.value {
            ::std::option::Option::Some(Exemplar_oneof_value::as_double(v)) => v,
            _ => 0.,
        }
    }
    pub fn clear_as_double(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_as_double(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(Exemplar_oneof_value::as_double(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_as_double(&mut self, v: f64) {
        self.value = ::std::option::Option::Some(Exemplar_oneof_value::as_double(v))
    }

    // sfixed64 as_int = 6;


    pub fn get_as_int(&self) -> i64 {
        match self.value {
            ::std::option::Option::Some(Exemplar_oneof_value::as_int(v)) => v,
            _ => 0,
        }
    }
    pub fn clear_as_int(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_as_int(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(Exemplar_oneof_value::as_int(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_as_int(&mut self, v: i64) {
        self.value = ::std::option::Option::Some(Exemplar_oneof_value::as_int(v))
    }

    // bytes span_id = 4;


    pub fn get_span_id(&self) -> &[u8] {
        &self.span_id
    }
    pub fn clear_span_id(&mut self) {
        self.span_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_span_id(&mut self, v: ::std::vec::Vec<u8>) {
        self.span_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_span_id(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.span_id
    }

    // Take field
    pub fn take_span_id(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.span_id, ::std::vec::Vec::new())
    }

    // bytes trace_id = 5;


    pub fn get_trace_id(&self) -> &[u8] {
        &self.trace_id
    }
    pub fn clear_trace_id(&mut self) {
        self.trace_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_trace_id(&mut self, v: ::std::vec::Vec<u8>) {
        self.trace_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_trace_id(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.trace_id
    }

    // Take field
    pub fn take_trace_id(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.trace_id, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for Exemplar {
    fn is_initialized(&self) -> bool {
        for v in &self.filtered_attributes {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.filtered_labels {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                7 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.filtered_attributes)?;
                },
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.filtered_labels)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.time_unix_nano = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(Exemplar_oneof_value::as_double(is.read_double()?));
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(Exemplar_oneof_value::as_int(is.read_sfixed64()?));
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.span_id)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.trace_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.filtered_attributes {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.filtered_labels {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.time_unix_nano != 0 {
            my_size += 9;
        }
        if !self.span_id.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.span_id);
        }
        if !self.trace_id.is_empty() {
            my_size += ::protobuf::rt::bytes_size(5, &self.trace_id);
        }
        if let ::std::option::Option::Some(ref v) = self.value {
            match v {
                &Exemplar_oneof_value::as_double(v) => {
                    my_size += 9;
                },
                &Exemplar_oneof_value::as_int(v) => {
                    my_size += 9;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.filtered_attributes {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.filtered_labels {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.time_unix_nano != 0 {
            os.write_fixed64(2, self.time_unix_nano)?;
        }
        if !self.span_id.is_empty() {
            os.write_bytes(4, &self.span_id)?;
        }
        if !self.trace_id.is_empty() {
            os.write_bytes(5, &self.trace_id)?;
        }
        if let ::std::option::Option::Some(ref v) = self.value {
            match v {
                &Exemplar_oneof_value::as_double(v) => {
                    os.write_double(3, v)?;
                },
                &Exemplar_oneof_value::as_int(v) => {
                    os.write_sfixed64(6, v)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Exemplar {
        Exemplar::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::KeyValue>>(
                "filtered_attributes",
                |m: &Exemplar| { &m.filtered_attributes },
                |m: &mut Exemplar| { &mut m.filtered_attributes },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::common::StringKeyValue>>(
                "filtered_labels",
                |m: &Exemplar| { &m.filtered_labels },
                |m: &mut Exemplar| { &mut m.filtered_labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "time_unix_nano",
                |m: &Exemplar| { &m.time_unix_nano },
                |m: &mut Exemplar| { &mut m.time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>(
                "as_double",
                Exemplar::has_as_double,
                Exemplar::get_as_double,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
                "as_int",
                Exemplar::has_as_int,
                Exemplar::get_as_int,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "span_id",
                |m: &Exemplar| { &m.span_id },
                |m: &mut Exemplar| { &mut m.span_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "trace_id",
                |m: &Exemplar| { &m.trace_id },
                |m: &mut Exemplar| { &mut m.trace_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Exemplar>(
                "Exemplar",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Exemplar {
        static instance: ::protobuf::rt::LazyV2<Exemplar> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Exemplar::new)
    }
}

impl ::protobuf::Clear for Exemplar {
    fn clear(&mut self) {
        self.filtered_attributes.clear();
        self.filtered_labels.clear();
        self.time_unix_nano = 0;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.span_id.clear();
        self.trace_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Exemplar {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Exemplar {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub enum AggregationTemporality {
    AGGREGATION_TEMPORALITY_UNSPECIFIED = 0,
    AGGREGATION_TEMPORALITY_DELTA = 1,
    AGGREGATION_TEMPORALITY_CUMULATIVE = 2,
}

impl ::protobuf::ProtobufEnum for AggregationTemporality {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<AggregationTemporality> {
        match value {
            0 => ::std::option::Option::Some(AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED),
            1 => ::std::option::Option::Some(AggregationTemporality::AGGREGATION_TEMPORALITY_DELTA),
            2 => ::std::option::Option::Some(AggregationTemporality::AGGREGATION_TEMPORALITY_CUMULATIVE),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [AggregationTemporality] = &[
            AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED,
            AggregationTemporality::AGGREGATION_TEMPORALITY_DELTA,
            AggregationTemporality::AGGREGATION_TEMPORALITY_CUMULATIVE,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<AggregationTemporality>("AggregationTemporality", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for AggregationTemporality {
}

impl ::std::default::Default for AggregationTemporality {
    fn default() -> Self {
        AggregationTemporality::AGGREGATION_TEMPORALITY_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for AggregationTemporality {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n,opentelemetry/proto/metrics/v1/metrics.proto\x12\x1eopentelemetry.pro\
    to.metrics.v1\x1a*opentelemetry/proto/common/v1/common.proto\x1a.opentel\
    emetry/proto/resource/v1/resource.proto\"\xe0\x01\n\x0fResourceMetrics\
    \x12E\n\x08resource\x18\x01\x20\x01(\x0b2).opentelemetry.proto.resource.\
    v1.ResourceR\x08resource\x12\x85\x01\n\x1finstrumentation_library_metric\
    s\x18\x02\x20\x03(\x0b2=.opentelemetry.proto.metrics.v1.InstrumentationL\
    ibraryMetricsR\x1dinstrumentationLibraryMetrics\"\xd1\x01\n\x1dInstrumen\
    tationLibraryMetrics\x12n\n\x17instrumentation_library\x18\x01\x20\x01(\
    \x0b25.opentelemetry.proto.common.v1.InstrumentationLibraryR\x16instrume\
    ntationLibrary\x12@\n\x07metrics\x18\x02\x20\x03(\x0b2&.opentelemetry.pr\
    oto.metrics.v1.MetricR\x07metrics\"\xcf\x04\n\x06Metric\x12\x12\n\x04nam\
    e\x18\x01\x20\x01(\tR\x04name\x12\x20\n\x0bdescription\x18\x02\x20\x01(\
    \tR\x0bdescription\x12\x12\n\x04unit\x18\x03\x20\x01(\tR\x04unit\x12K\n\
    \tint_gauge\x18\x04\x20\x01(\x0b2(.opentelemetry.proto.metrics.v1.IntGau\
    geH\0R\x08intGaugeB\x02\x18\x01\x12=\n\x05gauge\x18\x05\x20\x01(\x0b2%.o\
    pentelemetry.proto.metrics.v1.GaugeH\0R\x05gauge\x12E\n\x07int_sum\x18\
    \x06\x20\x01(\x0b2&.opentelemetry.proto.metrics.v1.IntSumH\0R\x06intSumB\
    \x02\x18\x01\x127\n\x03sum\x18\x07\x20\x01(\x0b2#.opentelemetry.proto.me\
    trics.v1.SumH\0R\x03sum\x12W\n\rint_histogram\x18\x08\x20\x01(\x0b2,.ope\
    ntelemetry.proto.metrics.v1.IntHistogramH\0R\x0cintHistogramB\x02\x18\
    \x01\x12I\n\thistogram\x18\t\x20\x01(\x0b2).opentelemetry.proto.metrics.\
    v1.HistogramH\0R\thistogram\x12C\n\x07summary\x18\x0b\x20\x01(\x0b2'.ope\
    ntelemetry.proto.metrics.v1.SummaryH\0R\x07summaryB\x06\n\x04data\"]\n\
    \x08IntGauge\x12M\n\x0bdata_points\x18\x01\x20\x03(\x0b2,.opentelemetry.\
    proto.metrics.v1.IntDataPointR\ndataPoints:\x02\x18\x01\"Y\n\x05Gauge\
    \x12P\n\x0bdata_points\x18\x01\x20\x03(\x0b2/.opentelemetry.proto.metric\
    s.v1.NumberDataPointR\ndataPoints\"\xef\x01\n\x06IntSum\x12M\n\x0bdata_p\
    oints\x18\x01\x20\x03(\x0b2,.opentelemetry.proto.metrics.v1.IntDataPoint\
    R\ndataPoints\x12o\n\x17aggregation_temporality\x18\x02\x20\x01(\x0e26.o\
    pentelemetry.proto.metrics.v1.AggregationTemporalityR\x16aggregationTemp\
    orality\x12!\n\x0cis_monotonic\x18\x03\x20\x01(\x08R\x0bisMonotonic:\x02\
    \x18\x01\"\xeb\x01\n\x03Sum\x12P\n\x0bdata_points\x18\x01\x20\x03(\x0b2/\
    .opentelemetry.proto.metrics.v1.NumberDataPointR\ndataPoints\x12o\n\x17a\
    ggregation_temporality\x18\x02\x20\x01(\x0e26.opentelemetry.proto.metric\
    s.v1.AggregationTemporalityR\x16aggregationTemporality\x12!\n\x0cis_mono\
    tonic\x18\x03\x20\x01(\x08R\x0bisMonotonic\"\xdb\x01\n\x0cIntHistogram\
    \x12V\n\x0bdata_points\x18\x01\x20\x03(\x0b25.opentelemetry.proto.metric\
    s.v1.IntHistogramDataPointR\ndataPoints\x12o\n\x17aggregation_temporalit\
    y\x18\x02\x20\x01(\x0e26.opentelemetry.proto.metrics.v1.AggregationTempo\
    ralityR\x16aggregationTemporality:\x02\x18\x01\"\xd1\x01\n\tHistogram\
    \x12S\n\x0bdata_points\x18\x01\x20\x03(\x0b22.opentelemetry.proto.metric\
    s.v1.HistogramDataPointR\ndataPoints\x12o\n\x17aggregation_temporality\
    \x18\x02\x20\x01(\x0e26.opentelemetry.proto.metrics.v1.AggregationTempor\
    alityR\x16aggregationTemporality\"\\\n\x07Summary\x12Q\n\x0bdata_points\
    \x18\x01\x20\x03(\x0b20.opentelemetry.proto.metrics.v1.SummaryDataPointR\
    \ndataPoints\"\x91\x02\n\x0cIntDataPoint\x12E\n\x06labels\x18\x01\x20\
    \x03(\x0b2-.opentelemetry.proto.common.v1.StringKeyValueR\x06labels\x12/\
    \n\x14start_time_unix_nano\x18\x02\x20\x01(\x06R\x11startTimeUnixNano\
    \x12$\n\x0etime_unix_nano\x18\x03\x20\x01(\x06R\x0ctimeUnixNano\x12\x14\
    \n\x05value\x18\x04\x20\x01(\x10R\x05value\x12I\n\texemplars\x18\x05\x20\
    \x03(\x0b2+.opentelemetry.proto.metrics.v1.IntExemplarR\texemplars:\x02\
    \x18\x01\"\x85\x03\n\x0fNumberDataPoint\x12G\n\nattributes\x18\x07\x20\
    \x03(\x0b2'.opentelemetry.proto.common.v1.KeyValueR\nattributes\x12I\n\
    \x06labels\x18\x01\x20\x03(\x0b2-.opentelemetry.proto.common.v1.StringKe\
    yValueR\x06labelsB\x02\x18\x01\x12/\n\x14start_time_unix_nano\x18\x02\
    \x20\x01(\x06R\x11startTimeUnixNano\x12$\n\x0etime_unix_nano\x18\x03\x20\
    \x01(\x06R\x0ctimeUnixNano\x12\x1d\n\tas_double\x18\x04\x20\x01(\x01H\0R\
    \x08asDouble\x12\x17\n\x06as_int\x18\x06\x20\x01(\x10H\0R\x05asInt\x12F\
    \n\texemplars\x18\x05\x20\x03(\x0b2(.opentelemetry.proto.metrics.v1.Exem\
    plarR\texemplarsB\x07\n\x05value\"\xfa\x02\n\x15IntHistogramDataPoint\
    \x12E\n\x06labels\x18\x01\x20\x03(\x0b2-.opentelemetry.proto.common.v1.S\
    tringKeyValueR\x06labels\x12/\n\x14start_time_unix_nano\x18\x02\x20\x01(\
    \x06R\x11startTimeUnixNano\x12$\n\x0etime_unix_nano\x18\x03\x20\x01(\x06\
    R\x0ctimeUnixNano\x12\x14\n\x05count\x18\x04\x20\x01(\x06R\x05count\x12\
    \x10\n\x03sum\x18\x05\x20\x01(\x10R\x03sum\x12#\n\rbucket_counts\x18\x06\
    \x20\x03(\x06R\x0cbucketCounts\x12'\n\x0fexplicit_bounds\x18\x07\x20\x03\
    (\x01R\x0eexplicitBounds\x12I\n\texemplars\x18\x08\x20\x03(\x0b2+.opente\
    lemetry.proto.metrics.v1.IntExemplarR\texemplars:\x02\x18\x01\"\xbd\x03\
    \n\x12HistogramDataPoint\x12G\n\nattributes\x18\t\x20\x03(\x0b2'.opentel\
    emetry.proto.common.v1.KeyValueR\nattributes\x12I\n\x06labels\x18\x01\
    \x20\x03(\x0b2-.opentelemetry.proto.common.v1.StringKeyValueR\x06labelsB\
    \x02\x18\x01\x12/\n\x14start_time_unix_nano\x18\x02\x20\x01(\x06R\x11sta\
    rtTimeUnixNano\x12$\n\x0etime_unix_nano\x18\x03\x20\x01(\x06R\x0ctimeUni\
    xNano\x12\x14\n\x05count\x18\x04\x20\x01(\x06R\x05count\x12\x10\n\x03sum\
    \x18\x05\x20\x01(\x01R\x03sum\x12#\n\rbucket_counts\x18\x06\x20\x03(\x06\
    R\x0cbucketCounts\x12'\n\x0fexplicit_bounds\x18\x07\x20\x03(\x01R\x0eexp\
    licitBounds\x12F\n\texemplars\x18\x08\x20\x03(\x0b2(.opentelemetry.proto\
    .metrics.v1.ExemplarR\texemplars\"\xd5\x03\n\x10SummaryDataPoint\x12G\n\
    \nattributes\x18\x07\x20\x03(\x0b2'.opentelemetry.proto.common.v1.KeyVal\
    ueR\nattributes\x12I\n\x06labels\x18\x01\x20\x03(\x0b2-.opentelemetry.pr\
    oto.common.v1.StringKeyValueR\x06labelsB\x02\x18\x01\x12/\n\x14start_tim\
    e_unix_nano\x18\x02\x20\x01(\x06R\x11startTimeUnixNano\x12$\n\x0etime_un\
    ix_nano\x18\x03\x20\x01(\x06R\x0ctimeUnixNano\x12\x14\n\x05count\x18\x04\
    \x20\x01(\x06R\x05count\x12\x10\n\x03sum\x18\x05\x20\x01(\x01R\x03sum\
    \x12i\n\x0fquantile_values\x18\x06\x20\x03(\x0b2@.opentelemetry.proto.me\
    trics.v1.SummaryDataPoint.ValueAtQuantileR\x0equantileValues\x1aC\n\x0fV\
    alueAtQuantile\x12\x1a\n\x08quantile\x18\x01\x20\x01(\x01R\x08quantile\
    \x12\x14\n\x05value\x18\x02\x20\x01(\x01R\x05value\"\xd9\x01\n\x0bIntExe\
    mplar\x12V\n\x0ffiltered_labels\x18\x01\x20\x03(\x0b2-.opentelemetry.pro\
    to.common.v1.StringKeyValueR\x0efilteredLabels\x12$\n\x0etime_unix_nano\
    \x18\x02\x20\x01(\x06R\x0ctimeUnixNano\x12\x14\n\x05value\x18\x03\x20\
    \x01(\x10R\x05value\x12\x17\n\x07span_id\x18\x04\x20\x01(\x0cR\x06spanId\
    \x12\x19\n\x08trace_id\x18\x05\x20\x01(\x0cR\x07traceId:\x02\x18\x01\"\
    \xdb\x02\n\x08Exemplar\x12X\n\x13filtered_attributes\x18\x07\x20\x03(\
    \x0b2'.opentelemetry.proto.common.v1.KeyValueR\x12filteredAttributes\x12\
    Z\n\x0ffiltered_labels\x18\x01\x20\x03(\x0b2-.opentelemetry.proto.common\
    .v1.StringKeyValueR\x0efilteredLabelsB\x02\x18\x01\x12$\n\x0etime_unix_n\
    ano\x18\x02\x20\x01(\x06R\x0ctimeUnixNano\x12\x1d\n\tas_double\x18\x03\
    \x20\x01(\x01H\0R\x08asDouble\x12\x17\n\x06as_int\x18\x06\x20\x01(\x10H\
    \0R\x05asInt\x12\x17\n\x07span_id\x18\x04\x20\x01(\x0cR\x06spanId\x12\
    \x19\n\x08trace_id\x18\x05\x20\x01(\x0cR\x07traceIdB\x07\n\x05value*\x8c\
    \x01\n\x16AggregationTemporality\x12'\n#AGGREGATION_TEMPORALITY_UNSPECIF\
    IED\x10\0\x12!\n\x1dAGGREGATION_TEMPORALITY_DELTA\x10\x01\x12&\n\"AGGREG\
    ATION_TEMPORALITY_CUMULATIVE\x10\x02Bt\n!io.opentelemetry.proto.metrics.\
    v1B\x0cMetricsProtoP\x01Z?github.com/open-telemetry/opentelemetry-proto/\
    gen/go/metrics/v1b\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}
