opentelemetry-proto 0.1.0

// This file is generated by rust-protobuf 2.27.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_27_1;

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct MetricsData {
    // message fields
    pub resource_metrics: ::protobuf::RepeatedField<ResourceMetrics>,
    // 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 MetricsData {
    fn default() -> &'a MetricsData {
        <MetricsData as ::protobuf::Message>::default_instance()
    }
}

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

    // repeated .opentelemetry.proto.metrics.v1.ResourceMetrics resource_metrics = 1;


    pub fn get_resource_metrics(&self) -> &[ResourceMetrics] {
        &self.resource_metrics
    }
    pub fn clear_resource_metrics(&mut self) {
        self.resource_metrics.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_resource_metrics(&mut self) -> &mut ::protobuf::RepeatedField<ResourceMetrics> {
        &mut self.resource_metrics
    }

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

impl ::protobuf::Message for MetricsData {
    fn is_initialized(&self) -> bool {
        for v in &self.resource_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_repeated_message_into(wire_type, is, &mut self.resource_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;
        for value in &self.resource_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<()> {
        for v in &self.resource_metrics {
            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() -> MetricsData {
        MetricsData::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<ResourceMetrics>>(
                "resource_metrics",
                |m: &MetricsData| { &m.resource_metrics },
                |m: &mut MetricsData| { &mut m.resource_metrics },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MetricsData>(
                "MetricsData",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for MetricsData {
    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 ResourceMetrics {
    // message fields
    pub resource: ::protobuf::SingularPtrField<super::resource::Resource>,
    pub instrumentation_library_metrics: ::protobuf::RepeatedField<InstrumentationLibraryMetrics>,
    pub schema_url: ::std::string::String,
    // 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())
    }

    // string schema_url = 3;


    pub fn get_schema_url(&self) -> &str {
        &self.schema_url
    }
    pub fn clear_schema_url(&mut self) {
        self.schema_url.clear();
    }

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

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

    // Take field
    pub fn take_schema_url(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.schema_url, ::std::string::String::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)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.schema_url)?;
                },
                _ => {
                    ::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;
        };
        if !self.schema_url.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.schema_url);
        }
        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)?;
        };
        if !self.schema_url.is_empty() {
            os.write_string(3, &self.schema_url)?;
        }
        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 },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "schema_url",
                |m: &ResourceMetrics| { &m.schema_url },
                |m: &mut ResourceMetrics| { &mut m.schema_url },
            ));
            ::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.schema_url.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>,
    pub schema_url: ::std::string::String,
    // 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())
    }

    // string schema_url = 3;


    pub fn get_schema_url(&self) -> &str {
        &self.schema_url
    }
    pub fn clear_schema_url(&mut self) {
        self.schema_url.clear();
    }

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

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

    // Take field
    pub fn take_schema_url(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.schema_url, ::std::string::String::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)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.schema_url)?;
                },
                _ => {
                    ::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;
        };
        if !self.schema_url.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.schema_url);
        }
        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)?;
        };
        if !self.schema_url.is_empty() {
            os.write_string(3, &self.schema_url)?;
        }
        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 },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "schema_url",
                |m: &InstrumentationLibraryMetrics| { &m.schema_url },
                |m: &mut InstrumentationLibraryMetrics| { &mut m.schema_url },
            ));
            ::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.schema_url.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 {
    gauge(Gauge),
    sum(Sum),
    histogram(Histogram),
    exponential_histogram(ExponentialHistogram),
    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.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.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.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.ExponentialHistogram exponential_histogram = 10;


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

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

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

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

    // Take field
    pub fn take_exponential_histogram(&mut self) -> ExponentialHistogram {
        if self.has_exponential_histogram() {
            match self.data.take() {
                ::std::option::Option::Some(Metric_oneof_data::exponential_histogram(v)) => v,
                _ => panic!(),
            }
        } else {
            ExponentialHistogram::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::gauge(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::histogram(ref v)) = self.data {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Metric_oneof_data::exponential_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)?;
                },
                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()?));
                },
                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()?));
                },
                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()?));
                },
                10 => {
                    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::exponential_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::gauge(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::histogram(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Metric_oneof_data::exponential_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::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::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::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::exponential_histogram(ref v) => {
                    os.write_tag(10, ::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::<_, Gauge>(
                "gauge",
                Metric::has_gauge,
                Metric::get_gauge,
            ));
            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::<_, Histogram>(
                "histogram",
                Metric::has_histogram,
                Metric::get_histogram,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ExponentialHistogram>(
                "exponential_histogram",
                Metric::has_exponential_histogram,
                Metric::get_exponential_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.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 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 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 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 ExponentialHistogram {
    // message fields
    pub data_points: ::protobuf::RepeatedField<ExponentialHistogramDataPoint>,
    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 ExponentialHistogram {
    fn default() -> &'a ExponentialHistogram {
        <ExponentialHistogram as ::protobuf::Message>::default_instance()
    }
}

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

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


    pub fn get_data_points(&self) -> &[ExponentialHistogramDataPoint] {
        &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<ExponentialHistogramDataPoint>) {
        self.data_points = v;
    }

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

    // Take field
    pub fn take_data_points(&mut self) -> ::protobuf::RepeatedField<ExponentialHistogramDataPoint> {
        ::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 ExponentialHistogram {
    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() -> ExponentialHistogram {
        ExponentialHistogram::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<ExponentialHistogramDataPoint>>(
                "data_points",
                |m: &ExponentialHistogram| { &m.data_points },
                |m: &mut ExponentialHistogram| { &mut m.data_points },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<AggregationTemporality>>(
                "aggregation_temporality",
                |m: &ExponentialHistogram| { &m.aggregation_temporality },
                |m: &mut ExponentialHistogram| { &mut m.aggregation_temporality },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExponentialHistogram>(
                "ExponentialHistogram",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for ExponentialHistogram {
    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 NumberDataPoint {
    // message fields
    pub attributes: ::protobuf::RepeatedField<super::common::KeyValue>,
    pub start_time_unix_nano: u64,
    pub time_unix_nano: u64,
    pub exemplars: ::protobuf::RepeatedField<Exemplar>,
    pub flags: u32,
    // 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())
    }

    // 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())
    }

    // uint32 flags = 8;


    pub fn get_flags(&self) -> u32 {
        self.flags
    }
    pub fn clear_flags(&mut self) {
        self.flags = 0;
    }

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

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.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)?;
                },
                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)?;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.flags = 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.attributes {
            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 self.flags != 0 {
            my_size += ::protobuf::rt::value_size(8, self.flags, ::protobuf::wire_format::WireTypeVarint);
        }
        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)?;
        };
        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 self.flags != 0 {
            os.write_uint32(8, self.flags)?;
        }
        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_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 },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "flags",
                |m: &NumberDataPoint| { &m.flags },
                |m: &mut NumberDataPoint| { &mut m.flags },
            ));
            ::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.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.flags = 0;
        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 HistogramDataPoint {
    // message fields
    pub attributes: ::protobuf::RepeatedField<super::common::KeyValue>,
    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>,
    pub flags: u32,
    // 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())
    }

    // 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())
    }

    // uint32 flags = 10;


    pub fn get_flags(&self) -> u32 {
        self.flags
    }
    pub fn clear_flags(&mut self) {
        self.flags = 0;
    }

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

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.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)?;
                },
                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)?;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.flags = 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.attributes {
            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;
        };
        if self.flags != 0 {
            my_size += ::protobuf::rt::value_size(10, self.flags, ::protobuf::wire_format::WireTypeVarint);
        }
        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)?;
        };
        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)?;
        };
        if self.flags != 0 {
            os.write_uint32(10, self.flags)?;
        }
        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_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 },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "flags",
                |m: &HistogramDataPoint| { &m.flags },
                |m: &mut HistogramDataPoint| { &mut m.flags },
            ));
            ::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.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.flags = 0;
        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 ExponentialHistogramDataPoint {
    // message fields
    pub attributes: ::protobuf::RepeatedField<super::common::KeyValue>,
    pub start_time_unix_nano: u64,
    pub time_unix_nano: u64,
    pub count: u64,
    pub sum: f64,
    pub scale: i32,
    pub zero_count: u64,
    pub positive: ::protobuf::SingularPtrField<ExponentialHistogramDataPoint_Buckets>,
    pub negative: ::protobuf::SingularPtrField<ExponentialHistogramDataPoint_Buckets>,
    pub flags: u32,
    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 ExponentialHistogramDataPoint {
    fn default() -> &'a ExponentialHistogramDataPoint {
        <ExponentialHistogramDataPoint as ::protobuf::Message>::default_instance()
    }
}

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

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


    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())
    }

    // 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;
    }

    // sint32 scale = 6;


    pub fn get_scale(&self) -> i32 {
        self.scale
    }
    pub fn clear_scale(&mut self) {
        self.scale = 0;
    }

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

    // fixed64 zero_count = 7;


    pub fn get_zero_count(&self) -> u64 {
        self.zero_count
    }
    pub fn clear_zero_count(&mut self) {
        self.zero_count = 0;
    }

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

    // .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets positive = 8;


    pub fn get_positive(&self) -> &ExponentialHistogramDataPoint_Buckets {
        self.positive.as_ref().unwrap_or_else(|| <ExponentialHistogramDataPoint_Buckets as ::protobuf::Message>::default_instance())
    }
    pub fn clear_positive(&mut self) {
        self.positive.clear();
    }

    pub fn has_positive(&self) -> bool {
        self.positive.is_some()
    }

    // Param is passed by value, moved
    pub fn set_positive(&mut self, v: ExponentialHistogramDataPoint_Buckets) {
        self.positive = ::protobuf::SingularPtrField::some(v);
    }

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

    // Take field
    pub fn take_positive(&mut self) -> ExponentialHistogramDataPoint_Buckets {
        self.positive.take().unwrap_or_else(|| ExponentialHistogramDataPoint_Buckets::new())
    }

    // .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets negative = 9;


    pub fn get_negative(&self) -> &ExponentialHistogramDataPoint_Buckets {
        self.negative.as_ref().unwrap_or_else(|| <ExponentialHistogramDataPoint_Buckets as ::protobuf::Message>::default_instance())
    }
    pub fn clear_negative(&mut self) {
        self.negative.clear();
    }

    pub fn has_negative(&self) -> bool {
        self.negative.is_some()
    }

    // Param is passed by value, moved
    pub fn set_negative(&mut self, v: ExponentialHistogramDataPoint_Buckets) {
        self.negative = ::protobuf::SingularPtrField::some(v);
    }

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

    // Take field
    pub fn take_negative(&mut self) -> ExponentialHistogramDataPoint_Buckets {
        self.negative.take().unwrap_or_else(|| ExponentialHistogramDataPoint_Buckets::new())
    }

    // uint32 flags = 10;


    pub fn get_flags(&self) -> u32 {
        self.flags
    }
    pub fn clear_flags(&mut self) {
        self.flags = 0;
    }

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

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


    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 ExponentialHistogramDataPoint {
    fn is_initialized(&self) -> bool {
        for v in &self.attributes {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.positive {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.negative {
            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.attributes)?;
                },
                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 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_sint32()?;
                    self.scale = tmp;
                },
                7 => {
                    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.zero_count = tmp;
                },
                8 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.positive)?;
                },
                9 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.negative)?;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.flags = tmp;
                },
                11 => {
                    ::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;
        };
        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;
        }
        if self.scale != 0 {
            my_size += ::protobuf::rt::value_varint_zigzag_size(6, self.scale);
        }
        if self.zero_count != 0 {
            my_size += 9;
        }
        if let Some(ref v) = self.positive.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.negative.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.flags != 0 {
            my_size += ::protobuf::rt::value_size(10, self.flags, ::protobuf::wire_format::WireTypeVarint);
        }
        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(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)?;
        }
        if self.scale != 0 {
            os.write_sint32(6, self.scale)?;
        }
        if self.zero_count != 0 {
            os.write_fixed64(7, self.zero_count)?;
        }
        if let Some(ref v) = self.positive.as_ref() {
            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.negative.as_ref() {
            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.flags != 0 {
            os.write_uint32(10, self.flags)?;
        }
        for v in &self.exemplars {
            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() -> ExponentialHistogramDataPoint {
        ExponentialHistogramDataPoint::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: &ExponentialHistogramDataPoint| { &m.attributes },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.attributes },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "start_time_unix_nano",
                |m: &ExponentialHistogramDataPoint| { &m.start_time_unix_nano },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.start_time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "time_unix_nano",
                |m: &ExponentialHistogramDataPoint| { &m.time_unix_nano },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.time_unix_nano },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "count",
                |m: &ExponentialHistogramDataPoint| { &m.count },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "sum",
                |m: &ExponentialHistogramDataPoint| { &m.sum },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.sum },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
                "scale",
                |m: &ExponentialHistogramDataPoint| { &m.scale },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.scale },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "zero_count",
                |m: &ExponentialHistogramDataPoint| { &m.zero_count },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.zero_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ExponentialHistogramDataPoint_Buckets>>(
                "positive",
                |m: &ExponentialHistogramDataPoint| { &m.positive },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.positive },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ExponentialHistogramDataPoint_Buckets>>(
                "negative",
                |m: &ExponentialHistogramDataPoint| { &m.negative },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.negative },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "flags",
                |m: &ExponentialHistogramDataPoint| { &m.flags },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.flags },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Exemplar>>(
                "exemplars",
                |m: &ExponentialHistogramDataPoint| { &m.exemplars },
                |m: &mut ExponentialHistogramDataPoint| { &mut m.exemplars },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExponentialHistogramDataPoint>(
                "ExponentialHistogramDataPoint",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ExponentialHistogramDataPoint {
    fn clear(&mut self) {
        self.attributes.clear();
        self.start_time_unix_nano = 0;
        self.time_unix_nano = 0;
        self.count = 0;
        self.sum = 0.;
        self.scale = 0;
        self.zero_count = 0;
        self.positive.clear();
        self.negative.clear();
        self.flags = 0;
        self.exemplars.clear();
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for ExponentialHistogramDataPoint {
    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 ExponentialHistogramDataPoint_Buckets {
    // message fields
    pub offset: i32,
    pub bucket_counts: ::std::vec::Vec<u64>,
    // 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 ExponentialHistogramDataPoint_Buckets {
    fn default() -> &'a ExponentialHistogramDataPoint_Buckets {
        <ExponentialHistogramDataPoint_Buckets as ::protobuf::Message>::default_instance()
    }
}

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

    // sint32 offset = 1;


    pub fn get_offset(&self) -> i32 {
        self.offset
    }
    pub fn clear_offset(&mut self) {
        self.offset = 0;
    }

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

    // repeated uint64 bucket_counts = 2;


    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())
    }
}

impl ::protobuf::Message for ExponentialHistogramDataPoint_Buckets {
    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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_sint32()?;
                    self.offset = tmp;
                },
                2 => {
                    ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.bucket_counts)?;
                },
                _ => {
                    ::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.offset != 0 {
            my_size += ::protobuf::rt::value_varint_zigzag_size(1, self.offset);
        }
        for value in &self.bucket_counts {
            my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        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.offset != 0 {
            os.write_sint32(1, self.offset)?;
        }
        for v in &self.bucket_counts {
            os.write_uint64(2, *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() -> ExponentialHistogramDataPoint_Buckets {
        ExponentialHistogramDataPoint_Buckets::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::ProtobufTypeSint32>(
                "offset",
                |m: &ExponentialHistogramDataPoint_Buckets| { &m.offset },
                |m: &mut ExponentialHistogramDataPoint_Buckets| { &mut m.offset },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "bucket_counts",
                |m: &ExponentialHistogramDataPoint_Buckets| { &m.bucket_counts },
                |m: &mut ExponentialHistogramDataPoint_Buckets| { &mut m.bucket_counts },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExponentialHistogramDataPoint_Buckets>(
                "ExponentialHistogramDataPoint.Buckets",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ExponentialHistogramDataPoint_Buckets {
    fn clear(&mut self) {
        self.offset = 0;
        self.bucket_counts.clear();
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for ExponentialHistogramDataPoint_Buckets {
    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 start_time_unix_nano: u64,
    pub time_unix_nano: u64,
    pub count: u64,
    pub sum: f64,
    pub quantile_values: ::protobuf::RepeatedField<SummaryDataPoint_ValueAtQuantile>,
    pub flags: u32,
    // 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())
    }

    // 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())
    }

    // uint32 flags = 8;


    pub fn get_flags(&self) -> u32 {
        self.flags
    }
    pub fn clear_flags(&mut self) {
        self.flags = 0;
    }

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

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.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)?;
                },
                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)?;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.flags = 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.attributes {
            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;
        };
        if self.flags != 0 {
            my_size += ::protobuf::rt::value_size(8, self.flags, ::protobuf::wire_format::WireTypeVarint);
        }
        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)?;
        };
        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)?;
        };
        if self.flags != 0 {
            os.write_uint32(8, self.flags)?;
        }
        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_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 },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "flags",
                |m: &SummaryDataPoint| { &m.flags },
                |m: &mut SummaryDataPoint| { &mut m.flags },
            ));
            ::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.start_time_unix_nano = 0;
        self.time_unix_nano = 0;
        self.count = 0;
        self.sum = 0.;
        self.quantile_values.clear();
        self.flags = 0;
        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 Exemplar {
    // message fields
    pub filtered_attributes: ::protobuf::RepeatedField<super::common::KeyValue>,
    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())
    }

    // 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;
            }
        };
        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)?;
                },
                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;
        };
        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)?;
        };
        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_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.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))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub enum DataPointFlags {
    FLAG_NONE = 0,
    FLAG_NO_RECORDED_VALUE = 1,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<DataPointFlags> {
        match value {
            0 => ::std::option::Option::Some(DataPointFlags::FLAG_NONE),
            1 => ::std::option::Option::Some(DataPointFlags::FLAG_NO_RECORDED_VALUE),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [DataPointFlags] = &[
            DataPointFlags::FLAG_NONE,
            DataPointFlags::FLAG_NO_RECORDED_VALUE,
        ];
        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::<DataPointFlags>("DataPointFlags", file_descriptor_proto())
        })
    }
}

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

impl ::std::default::Default for DataPointFlags {
    fn default() -> Self {
        DataPointFlags::FLAG_NONE
    }
}

impl ::protobuf::reflect::ProtobufValue for DataPointFlags {
    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\"i\n\x0bMetricsData\x12Z\n\x10re\
    source_metrics\x18\x01\x20\x03(\x0b2/.opentelemetry.proto.metrics.v1.Res\
    ourceMetricsR\x0fresourceMetrics\"\xff\x01\n\x0fResourceMetrics\x12E\n\
    \x08resource\x18\x01\x20\x01(\x0b2).opentelemetry.proto.resource.v1.Reso\
    urceR\x08resource\x12\x85\x01\n\x1finstrumentation_library_metrics\x18\
    \x02\x20\x03(\x0b2=.opentelemetry.proto.metrics.v1.InstrumentationLibrar\
    yMetricsR\x1dinstrumentationLibraryMetrics\x12\x1d\n\nschema_url\x18\x03\
    \x20\x01(\tR\tschemaUrl\"\xf0\x01\n\x1dInstrumentationLibraryMetrics\x12\
    n\n\x17instrumentation_library\x18\x01\x20\x01(\x0b25.opentelemetry.prot\
    o.common.v1.InstrumentationLibraryR\x16instrumentationLibrary\x12@\n\x07\
    metrics\x18\x02\x20\x03(\x0b2&.opentelemetry.proto.metrics.v1.MetricR\
    \x07metrics\x12\x1d\n\nschema_url\x18\x03\x20\x01(\tR\tschemaUrl\"\xe1\
    \x03\n\x06Metric\x12\x12\n\x04name\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\x12=\n\x05gauge\x18\x05\x20\x01(\x0b2%.opentele\
    metry.proto.metrics.v1.GaugeH\0R\x05gauge\x127\n\x03sum\x18\x07\x20\x01(\
    \x0b2#.opentelemetry.proto.metrics.v1.SumH\0R\x03sum\x12I\n\thistogram\
    \x18\t\x20\x01(\x0b2).opentelemetry.proto.metrics.v1.HistogramH\0R\thist\
    ogram\x12k\n\x15exponential_histogram\x18\n\x20\x01(\x0b24.opentelemetry\
    .proto.metrics.v1.ExponentialHistogramH\0R\x14exponentialHistogram\x12C\
    \n\x07summary\x18\x0b\x20\x01(\x0b2'.opentelemetry.proto.metrics.v1.Summ\
    aryH\0R\x07summaryB\x06\n\x04dataJ\x04\x08\x04\x10\x05J\x04\x08\x06\x10\
    \x07J\x04\x08\x08\x10\t\"Y\n\x05Gauge\x12P\n\x0bdata_points\x18\x01\x20\
    \x03(\x0b2/.opentelemetry.proto.metrics.v1.NumberDataPointR\ndataPoints\
    \"\xeb\x01\n\x03Sum\x12P\n\x0bdata_points\x18\x01\x20\x03(\x0b2/.opentel\
    emetry.proto.metrics.v1.NumberDataPointR\ndataPoints\x12o\n\x17aggregati\
    on_temporality\x18\x02\x20\x01(\x0e26.opentelemetry.proto.metrics.v1.Agg\
    regationTemporalityR\x16aggregationTemporality\x12!\n\x0cis_monotonic\
    \x18\x03\x20\x01(\x08R\x0bisMonotonic\"\xd1\x01\n\tHistogram\x12S\n\x0bd\
    ata_points\x18\x01\x20\x03(\x0b22.opentelemetry.proto.metrics.v1.Histogr\
    amDataPointR\ndataPoints\x12o\n\x17aggregation_temporality\x18\x02\x20\
    \x01(\x0e26.opentelemetry.proto.metrics.v1.AggregationTemporalityR\x16ag\
    gregationTemporality\"\xe7\x01\n\x14ExponentialHistogram\x12^\n\x0bdata_\
    points\x18\x01\x20\x03(\x0b2=.opentelemetry.proto.metrics.v1.Exponential\
    HistogramDataPointR\ndataPoints\x12o\n\x17aggregation_temporality\x18\
    \x02\x20\x01(\x0e26.opentelemetry.proto.metrics.v1.AggregationTemporalit\
    yR\x16aggregationTemporality\"\\\n\x07Summary\x12Q\n\x0bdata_points\x18\
    \x01\x20\x03(\x0b20.opentelemetry.proto.metrics.v1.SummaryDataPointR\nda\
    taPoints\"\xd6\x02\n\x0fNumberDataPoint\x12G\n\nattributes\x18\x07\x20\
    \x03(\x0b2'.opentelemetry.proto.common.v1.KeyValueR\nattributes\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(.open\
    telemetry.proto.metrics.v1.ExemplarR\texemplars\x12\x14\n\x05flags\x18\
    \x08\x20\x01(\rR\x05flagsB\x07\n\x05valueJ\x04\x08\x01\x10\x02\"\x8e\x03\
    \n\x12HistogramDataPoint\x12G\n\nattributes\x18\t\x20\x03(\x0b2'.opentel\
    emetry.proto.common.v1.KeyValueR\nattributes\x12/\n\x14start_time_unix_n\
    ano\x18\x02\x20\x01(\x06R\x11startTimeUnixNano\x12$\n\x0etime_unix_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\x12#\n\
    \rbucket_counts\x18\x06\x20\x03(\x06R\x0cbucketCounts\x12'\n\x0fexplicit\
    _bounds\x18\x07\x20\x03(\x01R\x0eexplicitBounds\x12F\n\texemplars\x18\
    \x08\x20\x03(\x0b2(.opentelemetry.proto.metrics.v1.ExemplarR\texemplars\
    \x12\x14\n\x05flags\x18\n\x20\x01(\rR\x05flagsJ\x04\x08\x01\x10\x02\"\
    \x88\x05\n\x1dExponentialHistogramDataPoint\x12G\n\nattributes\x18\x01\
    \x20\x03(\x0b2'.opentelemetry.proto.common.v1.KeyValueR\nattributes\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\x05count\x18\x04\x20\x01(\x06R\x05count\x12\x10\n\x03sum\x18\x05\x20\
    \x01(\x01R\x03sum\x12\x14\n\x05scale\x18\x06\x20\x01(\x11R\x05scale\x12\
    \x1d\n\nzero_count\x18\x07\x20\x01(\x06R\tzeroCount\x12a\n\x08positive\
    \x18\x08\x20\x01(\x0b2E.opentelemetry.proto.metrics.v1.ExponentialHistog\
    ramDataPoint.BucketsR\x08positive\x12a\n\x08negative\x18\t\x20\x01(\x0b2\
    E.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.BucketsR\
    \x08negative\x12\x14\n\x05flags\x18\n\x20\x01(\rR\x05flags\x12F\n\texemp\
    lars\x18\x0b\x20\x03(\x0b2(.opentelemetry.proto.metrics.v1.ExemplarR\tex\
    emplars\x1aF\n\x07Buckets\x12\x16\n\x06offset\x18\x01\x20\x01(\x11R\x06o\
    ffset\x12#\n\rbucket_counts\x18\x02\x20\x03(\x04R\x0cbucketCounts\"\xa6\
    \x03\n\x10SummaryDataPoint\x12G\n\nattributes\x18\x07\x20\x03(\x0b2'.ope\
    ntelemetry.proto.common.v1.KeyValueR\nattributes\x12/\n\x14start_time_un\
    ix_nano\x18\x02\x20\x01(\x06R\x11startTimeUnixNano\x12$\n\x0etime_unix_n\
    ano\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.metrics.v\
    1.SummaryDataPoint.ValueAtQuantileR\x0equantileValues\x12\x14\n\x05flags\
    \x18\x08\x20\x01(\rR\x05flags\x1aC\n\x0fValueAtQuantile\x12\x1a\n\x08qua\
    ntile\x18\x01\x20\x01(\x01R\x08quantile\x12\x14\n\x05value\x18\x02\x20\
    \x01(\x01R\x05valueJ\x04\x08\x01\x10\x02\"\x85\x02\n\x08Exemplar\x12X\n\
    \x13filtered_attributes\x18\x07\x20\x03(\x0b2'.opentelemetry.proto.commo\
    n.v1.KeyValueR\x12filteredAttributes\x12$\n\x0etime_unix_nano\x18\x02\
    \x20\x01(\x06R\x0ctimeUnixNano\x12\x1d\n\tas_double\x18\x03\x20\x01(\x01\
    H\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\x05valueJ\x04\x08\x01\x10\
    \x02*\x8c\x01\n\x16AggregationTemporality\x12'\n#AGGREGATION_TEMPORALITY\
    _UNSPECIFIED\x10\0\x12!\n\x1dAGGREGATION_TEMPORALITY_DELTA\x10\x01\x12&\
    \n\"AGGREGATION_TEMPORALITY_CUMULATIVE\x10\x02*;\n\x0eDataPointFlags\x12\
    \r\n\tFLAG_NONE\x10\0\x12\x1a\n\x16FLAG_NO_RECORDED_VALUE\x10\x01B^\n!io\
    .opentelemetry.proto.metrics.v1B\x0cMetricsProtoP\x01Z)go.opentelemetry.\
    io/proto/otlp/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()
    })
}