google-cloud-rust-raw 0.14.0

// This file is generated by rust-protobuf 2.28.0. 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 `google/api/distribution.proto`

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

#[derive(PartialEq,Clone,Default)]
pub struct Distribution {
    // message fields
    pub count: i64,
    pub mean: f64,
    pub sum_of_squared_deviation: f64,
    pub range: ::protobuf::SingularPtrField<Distribution_Range>,
    pub bucket_options: ::protobuf::SingularPtrField<Distribution_BucketOptions>,
    pub bucket_counts: ::std::vec::Vec<i64>,
    pub exemplars: ::protobuf::RepeatedField<Distribution_Exemplar>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int64 count = 1;


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

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

    // double mean = 2;


    pub fn get_mean(&self) -> f64 {
        self.mean
    }
    pub fn clear_mean(&mut self) {
        self.mean = 0.;
    }

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

    // double sum_of_squared_deviation = 3;


    pub fn get_sum_of_squared_deviation(&self) -> f64 {
        self.sum_of_squared_deviation
    }
    pub fn clear_sum_of_squared_deviation(&mut self) {
        self.sum_of_squared_deviation = 0.;
    }

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

    // .google.api.Distribution.Range range = 4;


    pub fn get_range(&self) -> &Distribution_Range {
        self.range.as_ref().unwrap_or_else(|| <Distribution_Range as ::protobuf::Message>::default_instance())
    }
    pub fn clear_range(&mut self) {
        self.range.clear();
    }

    pub fn has_range(&self) -> bool {
        self.range.is_some()
    }

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

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

    // Take field
    pub fn take_range(&mut self) -> Distribution_Range {
        self.range.take().unwrap_or_else(|| Distribution_Range::new())
    }

    // .google.api.Distribution.BucketOptions bucket_options = 6;


    pub fn get_bucket_options(&self) -> &Distribution_BucketOptions {
        self.bucket_options.as_ref().unwrap_or_else(|| <Distribution_BucketOptions as ::protobuf::Message>::default_instance())
    }
    pub fn clear_bucket_options(&mut self) {
        self.bucket_options.clear();
    }

    pub fn has_bucket_options(&self) -> bool {
        self.bucket_options.is_some()
    }

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

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

    // Take field
    pub fn take_bucket_options(&mut self) -> Distribution_BucketOptions {
        self.bucket_options.take().unwrap_or_else(|| Distribution_BucketOptions::new())
    }

    // repeated int64 bucket_counts = 7;


    pub fn get_bucket_counts(&self) -> &[i64] {
        &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<i64>) {
        self.bucket_counts = v;
    }

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

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

    // repeated .google.api.Distribution.Exemplar exemplars = 10;


    pub fn get_exemplars(&self) -> &[Distribution_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<Distribution_Exemplar>) {
        self.exemplars = v;
    }

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

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

impl ::protobuf::Message for Distribution {
    fn is_initialized(&self) -> bool {
        for v in &self.range {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.bucket_options {
            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 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.count = 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.mean = 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_double()?;
                    self.sum_of_squared_deviation = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.range)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.bucket_options)?;
                },
                7 => {
                    ::protobuf::rt::read_repeated_int64_into(wire_type, is, &mut self.bucket_counts)?;
                },
                10 => {
                    ::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;
        if self.count != 0 {
            my_size += ::protobuf::rt::value_size(1, self.count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.mean != 0. {
            my_size += 9;
        }
        if self.sum_of_squared_deviation != 0. {
            my_size += 9;
        }
        if let Some(ref v) = self.range.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.bucket_options.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.bucket_counts {
            my_size += ::protobuf::rt::value_size(7, *value, ::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<()> {
        if self.count != 0 {
            os.write_int64(1, self.count)?;
        }
        if self.mean != 0. {
            os.write_double(2, self.mean)?;
        }
        if self.sum_of_squared_deviation != 0. {
            os.write_double(3, self.sum_of_squared_deviation)?;
        }
        if let Some(ref v) = self.range.as_ref() {
            os.write_tag(4, ::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.bucket_options.as_ref() {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.bucket_counts {
            os.write_int64(7, *v)?;
        };
        for v in &self.exemplars {
            os.write_tag(10, ::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() -> Distribution {
        Distribution::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::ProtobufTypeInt64>(
                "count",
                |m: &Distribution| { &m.count },
                |m: &mut Distribution| { &mut m.count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "mean",
                |m: &Distribution| { &m.mean },
                |m: &mut Distribution| { &mut m.mean },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "sum_of_squared_deviation",
                |m: &Distribution| { &m.sum_of_squared_deviation },
                |m: &mut Distribution| { &mut m.sum_of_squared_deviation },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Distribution_Range>>(
                "range",
                |m: &Distribution| { &m.range },
                |m: &mut Distribution| { &mut m.range },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Distribution_BucketOptions>>(
                "bucket_options",
                |m: &Distribution| { &m.bucket_options },
                |m: &mut Distribution| { &mut m.bucket_options },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "bucket_counts",
                |m: &Distribution| { &m.bucket_counts },
                |m: &mut Distribution| { &mut m.bucket_counts },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Distribution_Exemplar>>(
                "exemplars",
                |m: &Distribution| { &m.exemplars },
                |m: &mut Distribution| { &mut m.exemplars },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Distribution>(
                "Distribution",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for Distribution {
    fn clear(&mut self) {
        self.count = 0;
        self.mean = 0.;
        self.sum_of_squared_deviation = 0.;
        self.range.clear();
        self.bucket_options.clear();
        self.bucket_counts.clear();
        self.exemplars.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct Distribution_Range {
    // message fields
    pub min: f64,
    pub max: f64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // double min = 1;


    pub fn get_min(&self) -> f64 {
        self.min
    }
    pub fn clear_min(&mut self) {
        self.min = 0.;
    }

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

    // double max = 2;


    pub fn get_max(&self) -> f64 {
        self.max
    }
    pub fn clear_max(&mut self) {
        self.max = 0.;
    }

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

impl ::protobuf::Message for Distribution_Range {
    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.min = 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.max = 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.min != 0. {
            my_size += 9;
        }
        if self.max != 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.min != 0. {
            os.write_double(1, self.min)?;
        }
        if self.max != 0. {
            os.write_double(2, self.max)?;
        }
        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() -> Distribution_Range {
        Distribution_Range::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>(
                "min",
                |m: &Distribution_Range| { &m.min },
                |m: &mut Distribution_Range| { &mut m.min },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "max",
                |m: &Distribution_Range| { &m.max },
                |m: &mut Distribution_Range| { &mut m.max },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Distribution_Range>(
                "Distribution.Range",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for Distribution_Range {
    fn clear(&mut self) {
        self.min = 0.;
        self.max = 0.;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct Distribution_BucketOptions {
    // message oneof groups
    pub options: ::std::option::Option<Distribution_BucketOptions_oneof_options>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum Distribution_BucketOptions_oneof_options {
    linear_buckets(Distribution_BucketOptions_Linear),
    exponential_buckets(Distribution_BucketOptions_Exponential),
    explicit_buckets(Distribution_BucketOptions_Explicit),
}

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

    // .google.api.Distribution.BucketOptions.Linear linear_buckets = 1;


    pub fn get_linear_buckets(&self) -> &Distribution_BucketOptions_Linear {
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::linear_buckets(ref v)) => v,
            _ => <Distribution_BucketOptions_Linear as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_linear_buckets(&mut self) {
        self.options = ::std::option::Option::None;
    }

    pub fn has_linear_buckets(&self) -> bool {
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::linear_buckets(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_linear_buckets(&mut self, v: Distribution_BucketOptions_Linear) {
        self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::linear_buckets(v))
    }

    // Mutable pointer to the field.
    pub fn mut_linear_buckets(&mut self) -> &mut Distribution_BucketOptions_Linear {
        if let ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::linear_buckets(_)) = self.options {
        } else {
            self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::linear_buckets(Distribution_BucketOptions_Linear::new()));
        }
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::linear_buckets(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_linear_buckets(&mut self) -> Distribution_BucketOptions_Linear {
        if self.has_linear_buckets() {
            match self.options.take() {
                ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::linear_buckets(v)) => v,
                _ => panic!(),
            }
        } else {
            Distribution_BucketOptions_Linear::new()
        }
    }

    // .google.api.Distribution.BucketOptions.Exponential exponential_buckets = 2;


    pub fn get_exponential_buckets(&self) -> &Distribution_BucketOptions_Exponential {
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::exponential_buckets(ref v)) => v,
            _ => <Distribution_BucketOptions_Exponential as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_exponential_buckets(&mut self) {
        self.options = ::std::option::Option::None;
    }

    pub fn has_exponential_buckets(&self) -> bool {
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::exponential_buckets(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_exponential_buckets(&mut self, v: Distribution_BucketOptions_Exponential) {
        self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::exponential_buckets(v))
    }

    // Mutable pointer to the field.
    pub fn mut_exponential_buckets(&mut self) -> &mut Distribution_BucketOptions_Exponential {
        if let ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::exponential_buckets(_)) = self.options {
        } else {
            self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::exponential_buckets(Distribution_BucketOptions_Exponential::new()));
        }
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::exponential_buckets(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_exponential_buckets(&mut self) -> Distribution_BucketOptions_Exponential {
        if self.has_exponential_buckets() {
            match self.options.take() {
                ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::exponential_buckets(v)) => v,
                _ => panic!(),
            }
        } else {
            Distribution_BucketOptions_Exponential::new()
        }
    }

    // .google.api.Distribution.BucketOptions.Explicit explicit_buckets = 3;


    pub fn get_explicit_buckets(&self) -> &Distribution_BucketOptions_Explicit {
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::explicit_buckets(ref v)) => v,
            _ => <Distribution_BucketOptions_Explicit as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_explicit_buckets(&mut self) {
        self.options = ::std::option::Option::None;
    }

    pub fn has_explicit_buckets(&self) -> bool {
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::explicit_buckets(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_explicit_buckets(&mut self, v: Distribution_BucketOptions_Explicit) {
        self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::explicit_buckets(v))
    }

    // Mutable pointer to the field.
    pub fn mut_explicit_buckets(&mut self) -> &mut Distribution_BucketOptions_Explicit {
        if let ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::explicit_buckets(_)) = self.options {
        } else {
            self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::explicit_buckets(Distribution_BucketOptions_Explicit::new()));
        }
        match self.options {
            ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::explicit_buckets(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_explicit_buckets(&mut self) -> Distribution_BucketOptions_Explicit {
        if self.has_explicit_buckets() {
            match self.options.take() {
                ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::explicit_buckets(v)) => v,
                _ => panic!(),
            }
        } else {
            Distribution_BucketOptions_Explicit::new()
        }
    }
}

impl ::protobuf::Message for Distribution_BucketOptions {
    fn is_initialized(&self) -> bool {
        if let Some(Distribution_BucketOptions_oneof_options::linear_buckets(ref v)) = self.options {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Distribution_BucketOptions_oneof_options::exponential_buckets(ref v)) = self.options {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Distribution_BucketOptions_oneof_options::explicit_buckets(ref v)) = self.options {
            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 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::linear_buckets(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::exponential_buckets(is.read_message()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.options = ::std::option::Option::Some(Distribution_BucketOptions_oneof_options::explicit_buckets(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 let ::std::option::Option::Some(ref v) = self.options {
            match v {
                &Distribution_BucketOptions_oneof_options::linear_buckets(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Distribution_BucketOptions_oneof_options::exponential_buckets(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Distribution_BucketOptions_oneof_options::explicit_buckets(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 let ::std::option::Option::Some(ref v) = self.options {
            match v {
                &Distribution_BucketOptions_oneof_options::linear_buckets(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Distribution_BucketOptions_oneof_options::exponential_buckets(ref v) => {
                    os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Distribution_BucketOptions_oneof_options::explicit_buckets(ref v) => {
                    os.write_tag(3, ::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() -> Distribution_BucketOptions {
        Distribution_BucketOptions::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_message_accessor::<_, Distribution_BucketOptions_Linear>(
                "linear_buckets",
                Distribution_BucketOptions::has_linear_buckets,
                Distribution_BucketOptions::get_linear_buckets,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Distribution_BucketOptions_Exponential>(
                "exponential_buckets",
                Distribution_BucketOptions::has_exponential_buckets,
                Distribution_BucketOptions::get_exponential_buckets,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Distribution_BucketOptions_Explicit>(
                "explicit_buckets",
                Distribution_BucketOptions::has_explicit_buckets,
                Distribution_BucketOptions::get_explicit_buckets,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Distribution_BucketOptions>(
                "Distribution.BucketOptions",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for Distribution_BucketOptions {
    fn clear(&mut self) {
        self.options = ::std::option::Option::None;
        self.options = ::std::option::Option::None;
        self.options = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct Distribution_BucketOptions_Linear {
    // message fields
    pub num_finite_buckets: i32,
    pub width: f64,
    pub offset: f64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int32 num_finite_buckets = 1;


    pub fn get_num_finite_buckets(&self) -> i32 {
        self.num_finite_buckets
    }
    pub fn clear_num_finite_buckets(&mut self) {
        self.num_finite_buckets = 0;
    }

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

    // double width = 2;


    pub fn get_width(&self) -> f64 {
        self.width
    }
    pub fn clear_width(&mut self) {
        self.width = 0.;
    }

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

    // double offset = 3;


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

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

impl ::protobuf::Message for Distribution_BucketOptions_Linear {
    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_int32()?;
                    self.num_finite_buckets = 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.width = 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_double()?;
                    self.offset = 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.num_finite_buckets != 0 {
            my_size += ::protobuf::rt::value_size(1, self.num_finite_buckets, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.width != 0. {
            my_size += 9;
        }
        if self.offset != 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.num_finite_buckets != 0 {
            os.write_int32(1, self.num_finite_buckets)?;
        }
        if self.width != 0. {
            os.write_double(2, self.width)?;
        }
        if self.offset != 0. {
            os.write_double(3, self.offset)?;
        }
        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() -> Distribution_BucketOptions_Linear {
        Distribution_BucketOptions_Linear::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::ProtobufTypeInt32>(
                "num_finite_buckets",
                |m: &Distribution_BucketOptions_Linear| { &m.num_finite_buckets },
                |m: &mut Distribution_BucketOptions_Linear| { &mut m.num_finite_buckets },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "width",
                |m: &Distribution_BucketOptions_Linear| { &m.width },
                |m: &mut Distribution_BucketOptions_Linear| { &mut m.width },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "offset",
                |m: &Distribution_BucketOptions_Linear| { &m.offset },
                |m: &mut Distribution_BucketOptions_Linear| { &mut m.offset },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Distribution_BucketOptions_Linear>(
                "Distribution.BucketOptions.Linear",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct Distribution_BucketOptions_Exponential {
    // message fields
    pub num_finite_buckets: i32,
    pub growth_factor: f64,
    pub scale: f64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int32 num_finite_buckets = 1;


    pub fn get_num_finite_buckets(&self) -> i32 {
        self.num_finite_buckets
    }
    pub fn clear_num_finite_buckets(&mut self) {
        self.num_finite_buckets = 0;
    }

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

    // double growth_factor = 2;


    pub fn get_growth_factor(&self) -> f64 {
        self.growth_factor
    }
    pub fn clear_growth_factor(&mut self) {
        self.growth_factor = 0.;
    }

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

    // double scale = 3;


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

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

impl ::protobuf::Message for Distribution_BucketOptions_Exponential {
    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_int32()?;
                    self.num_finite_buckets = 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.growth_factor = 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_double()?;
                    self.scale = 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.num_finite_buckets != 0 {
            my_size += ::protobuf::rt::value_size(1, self.num_finite_buckets, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.growth_factor != 0. {
            my_size += 9;
        }
        if self.scale != 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.num_finite_buckets != 0 {
            os.write_int32(1, self.num_finite_buckets)?;
        }
        if self.growth_factor != 0. {
            os.write_double(2, self.growth_factor)?;
        }
        if self.scale != 0. {
            os.write_double(3, self.scale)?;
        }
        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() -> Distribution_BucketOptions_Exponential {
        Distribution_BucketOptions_Exponential::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::ProtobufTypeInt32>(
                "num_finite_buckets",
                |m: &Distribution_BucketOptions_Exponential| { &m.num_finite_buckets },
                |m: &mut Distribution_BucketOptions_Exponential| { &mut m.num_finite_buckets },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "growth_factor",
                |m: &Distribution_BucketOptions_Exponential| { &m.growth_factor },
                |m: &mut Distribution_BucketOptions_Exponential| { &mut m.growth_factor },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "scale",
                |m: &Distribution_BucketOptions_Exponential| { &m.scale },
                |m: &mut Distribution_BucketOptions_Exponential| { &mut m.scale },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Distribution_BucketOptions_Exponential>(
                "Distribution.BucketOptions.Exponential",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for Distribution_BucketOptions_Exponential {
    fn clear(&mut self) {
        self.num_finite_buckets = 0;
        self.growth_factor = 0.;
        self.scale = 0.;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct Distribution_BucketOptions_Explicit {
    // message fields
    pub bounds: ::std::vec::Vec<f64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated double bounds = 1;


    pub fn get_bounds(&self) -> &[f64] {
        &self.bounds
    }
    pub fn clear_bounds(&mut self) {
        self.bounds.clear();
    }

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

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

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

impl ::protobuf::Message for Distribution_BucketOptions_Explicit {
    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 => {
                    ::protobuf::rt::read_repeated_double_into(wire_type, is, &mut self.bounds)?;
                },
                _ => {
                    ::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;
        my_size += 9 * self.bounds.len() as u32;
        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.bounds {
            os.write_double(1, *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() -> Distribution_BucketOptions_Explicit {
        Distribution_BucketOptions_Explicit::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_vec_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "bounds",
                |m: &Distribution_BucketOptions_Explicit| { &m.bounds },
                |m: &mut Distribution_BucketOptions_Explicit| { &mut m.bounds },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Distribution_BucketOptions_Explicit>(
                "Distribution.BucketOptions.Explicit",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct Distribution_Exemplar {
    // message fields
    pub value: f64,
    pub timestamp: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    pub attachments: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // double value = 1;


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

    // .google.protobuf.Timestamp timestamp = 2;


    pub fn get_timestamp(&self) -> &::protobuf::well_known_types::Timestamp {
        self.timestamp.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_timestamp(&mut self) {
        self.timestamp.clear();
    }

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.timestamp = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.timestamp.is_none() {
            self.timestamp.set_default();
        }
        self.timestamp.as_mut().unwrap()
    }

    // Take field
    pub fn take_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.timestamp.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }

    // repeated .google.protobuf.Any attachments = 3;


    pub fn get_attachments(&self) -> &[::protobuf::well_known_types::Any] {
        &self.attachments
    }
    pub fn clear_attachments(&mut self) {
        self.attachments.clear();
    }

    // Param is passed by value, moved
    pub fn set_attachments(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>) {
        self.attachments = v;
    }

    // Mutable pointer to the field.
    pub fn mut_attachments(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Any> {
        &mut self.attachments
    }

    // Take field
    pub fn take_attachments(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Any> {
        ::std::mem::replace(&mut self.attachments, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for Distribution_Exemplar {
    fn is_initialized(&self) -> bool {
        for v in &self.timestamp {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.attachments {
            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 => {
                    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;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.timestamp)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.attachments)?;
                },
                _ => {
                    ::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.value != 0. {
            my_size += 9;
        }
        if let Some(ref v) = self.timestamp.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.attachments {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.value != 0. {
            os.write_double(1, self.value)?;
        }
        if let Some(ref v) = self.timestamp.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.attachments {
            os.write_tag(3, ::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() -> Distribution_Exemplar {
        Distribution_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_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "value",
                |m: &Distribution_Exemplar| { &m.value },
                |m: &mut Distribution_Exemplar| { &mut m.value },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "timestamp",
                |m: &Distribution_Exemplar| { &m.timestamp },
                |m: &mut Distribution_Exemplar| { &mut m.timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>(
                "attachments",
                |m: &Distribution_Exemplar| { &m.attachments },
                |m: &mut Distribution_Exemplar| { &mut m.attachments },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Distribution_Exemplar>(
                "Distribution.Exemplar",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x1dgoogle/api/distribution.proto\x12\ngoogle.api\x1a\x19google/protob\
    uf/any.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xda\x08\n\x0cDistr\
    ibution\x12\x14\n\x05count\x18\x01\x20\x01(\x03R\x05count\x12\x12\n\x04m\
    ean\x18\x02\x20\x01(\x01R\x04mean\x127\n\x18sum_of_squared_deviation\x18\
    \x03\x20\x01(\x01R\x15sumOfSquaredDeviation\x124\n\x05range\x18\x04\x20\
    \x01(\x0b2\x1e.google.api.Distribution.RangeR\x05range\x12M\n\x0ebucket_\
    options\x18\x06\x20\x01(\x0b2&.google.api.Distribution.BucketOptionsR\rb\
    ucketOptions\x12#\n\rbucket_counts\x18\x07\x20\x03(\x03R\x0cbucketCounts\
    \x12?\n\texemplars\x18\n\x20\x03(\x0b2!.google.api.Distribution.Exemplar\
    R\texemplars\x1a+\n\x05Range\x12\x10\n\x03min\x18\x01\x20\x01(\x01R\x03m\
    in\x12\x10\n\x03max\x18\x02\x20\x01(\x01R\x03max\x1a\xb9\x04\n\rBucketOp\
    tions\x12V\n\x0elinear_buckets\x18\x01\x20\x01(\x0b2-.google.api.Distrib\
    ution.BucketOptions.LinearH\0R\rlinearBuckets\x12e\n\x13exponential_buck\
    ets\x18\x02\x20\x01(\x0b22.google.api.Distribution.BucketOptions.Exponen\
    tialH\0R\x12exponentialBuckets\x12\\\n\x10explicit_buckets\x18\x03\x20\
    \x01(\x0b2/.google.api.Distribution.BucketOptions.ExplicitH\0R\x0fexplic\
    itBuckets\x1ad\n\x06Linear\x12,\n\x12num_finite_buckets\x18\x01\x20\x01(\
    \x05R\x10numFiniteBuckets\x12\x14\n\x05width\x18\x02\x20\x01(\x01R\x05wi\
    dth\x12\x16\n\x06offset\x18\x03\x20\x01(\x01R\x06offset\x1av\n\x0bExpone\
    ntial\x12,\n\x12num_finite_buckets\x18\x01\x20\x01(\x05R\x10numFiniteBuc\
    kets\x12#\n\rgrowth_factor\x18\x02\x20\x01(\x01R\x0cgrowthFactor\x12\x14\
    \n\x05scale\x18\x03\x20\x01(\x01R\x05scale\x1a\"\n\x08Explicit\x12\x16\n\
    \x06bounds\x18\x01\x20\x03(\x01R\x06boundsB\t\n\x07options\x1a\x92\x01\n\
    \x08Exemplar\x12\x14\n\x05value\x18\x01\x20\x01(\x01R\x05value\x128\n\tt\
    imestamp\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\ttimestamp\
    \x126\n\x0battachments\x18\x03\x20\x03(\x0b2\x14.google.protobuf.AnyR\
    \x0battachmentsBq\n\x0ecom.google.apiB\x11DistributionProtoP\x01ZCgoogle\
    .golang.org/genproto/googleapis/api/distribution;distribution\xa2\x02\
    \x04GAPIJ\x81D\n\x07\x12\x05\x0f\0\xd3\x01\x01\n\xbe\x04\n\x01\x0c\x12\
    \x03\x0f\0\x122\xb3\x04\x20Copyright\x202019\x20Google\x20LLC.\n\n\x20Li\
    censed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\
    \x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20excep\
    t\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20obta\
    in\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20htt\
    p://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\
    \x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20softwar\
    e\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\x20on\
    \x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CON\
    DITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\
    \x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20gover\
    ning\x20permissions\x20and\n\x20limitations\x20under\x20the\x20License.\
    \n\n\n\x08\n\x01\x02\x12\x03\x11\0\x13\n\t\n\x02\x03\0\x12\x03\x13\0#\n\
    \t\n\x02\x03\x01\x12\x03\x14\0)\n\x08\n\x01\x08\x12\x03\x16\0Z\n\t\n\x02\
    \x08\x0b\x12\x03\x16\0Z\n\x08\n\x01\x08\x12\x03\x17\0\"\n\t\n\x02\x08\n\
    \x12\x03\x17\0\"\n\x08\n\x01\x08\x12\x03\x18\02\n\t\n\x02\x08\x08\x12\
    \x03\x18\02\n\x08\n\x01\x08\x12\x03\x19\0'\n\t\n\x02\x08\x01\x12\x03\x19\
    \0'\n\x08\n\x01\x08\x12\x03\x1a\0\"\n\t\n\x02\x08$\x12\x03\x1a\0\"\n\xaa\
    \x06\n\x02\x04\0\x12\x05*\0\xd3\x01\x01\x1a\x9c\x06\x20`Distribution`\
    \x20contains\x20summary\x20statistics\x20for\x20a\x20population\x20of\
    \x20values.\x20It\n\x20optionally\x20contains\x20a\x20histogram\x20repre\
    senting\x20the\x20distribution\x20of\x20those\x20values\n\x20across\x20a\
    \x20set\x20of\x20buckets.\n\n\x20The\x20summary\x20statistics\x20are\x20\
    the\x20count,\x20mean,\x20sum\x20of\x20the\x20squared\x20deviation\x20fr\
    om\n\x20the\x20mean,\x20the\x20minimum,\x20and\x20the\x20maximum\x20of\
    \x20the\x20set\x20of\x20population\x20of\x20values.\n\x20The\x20histogra\
    m\x20is\x20based\x20on\x20a\x20sequence\x20of\x20buckets\x20and\x20gives\
    \x20a\x20count\x20of\x20values\n\x20that\x20fall\x20into\x20each\x20buck\
    et.\x20The\x20boundaries\x20of\x20the\x20buckets\x20are\x20given\x20eith\
    er\n\x20explicitly\x20or\x20by\x20formulas\x20for\x20buckets\x20of\x20fi\
    xed\x20or\x20exponentially\x20increasing\n\x20widths.\n\n\x20Although\
    \x20it\x20is\x20not\x20forbidden,\x20it\x20is\x20generally\x20a\x20bad\
    \x20idea\x20to\x20include\n\x20non-finite\x20values\x20(infinities\x20or\
    \x20NaNs)\x20in\x20the\x20population\x20of\x20values,\x20as\x20this\n\
    \x20will\x20render\x20the\x20`mean`\x20and\x20`sum_of_squared_deviation`\
    \x20fields\x20meaningless.\n\n\n\n\x03\x04\0\x01\x12\x03*\x08\x14\n3\n\
    \x04\x04\0\x03\0\x12\x04,\x022\x03\x1a%\x20The\x20range\x20of\x20the\x20\
    population\x20values.\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\x03,\n\x0f\n6\n\
    \x06\x04\0\x03\0\x02\0\x12\x03.\x04\x13\x1a'\x20The\x20minimum\x20of\x20\
    the\x20population\x20values.\n\n\x0e\n\x07\x04\0\x03\0\x02\0\x05\x12\x03\
    .\x04\n\n\x0e\n\x07\x04\0\x03\0\x02\0\x01\x12\x03.\x0b\x0e\n\x0e\n\x07\
    \x04\0\x03\0\x02\0\x03\x12\x03.\x11\x12\n6\n\x06\x04\0\x03\0\x02\x01\x12\
    \x031\x04\x13\x1a'\x20The\x20maximum\x20of\x20the\x20population\x20value\
    s.\n\n\x0e\n\x07\x04\0\x03\0\x02\x01\x05\x12\x031\x04\n\n\x0e\n\x07\x04\
    \0\x03\0\x02\x01\x01\x12\x031\x0b\x0e\n\x0e\n\x07\x04\0\x03\0\x02\x01\
    \x03\x12\x031\x11\x12\n\xf3\x07\n\x04\x04\0\x03\x01\x12\x05C\x02\x87\x01\
    \x03\x1a\xe3\x07\x20`BucketOptions`\x20describes\x20the\x20bucket\x20bou\
    ndaries\x20used\x20to\x20create\x20a\x20histogram\n\x20for\x20the\x20dis\
    tribution.\x20The\x20buckets\x20can\x20be\x20in\x20a\x20linear\x20sequen\
    ce,\x20an\n\x20exponential\x20sequence,\x20or\x20each\x20bucket\x20can\
    \x20be\x20specified\x20explicitly.\n\x20`BucketOptions`\x20does\x20not\
    \x20include\x20the\x20number\x20of\x20values\x20in\x20each\x20bucket.\n\
    \n\x20A\x20bucket\x20has\x20an\x20inclusive\x20lower\x20bound\x20and\x20\
    exclusive\x20upper\x20bound\x20for\x20the\n\x20values\x20that\x20are\x20\
    counted\x20for\x20that\x20bucket.\x20The\x20upper\x20bound\x20of\x20a\
    \x20bucket\x20must\n\x20be\x20strictly\x20greater\x20than\x20the\x20lowe\
    r\x20bound.\x20The\x20sequence\x20of\x20N\x20buckets\x20for\x20a\n\x20di\
    stribution\x20consists\x20of\x20an\x20underflow\x20bucket\x20(number\x20\
    0),\x20zero\x20or\x20more\n\x20finite\x20buckets\x20(number\x201\x20thro\
    ugh\x20N\x20-\x202)\x20and\x20an\x20overflow\x20bucket\x20(number\x20N\
    \x20-\n\x201).\x20The\x20buckets\x20are\x20contiguous:\x20the\x20lower\
    \x20bound\x20of\x20bucket\x20i\x20(i\x20>\x200)\x20is\x20the\n\x20same\
    \x20as\x20the\x20upper\x20bound\x20of\x20bucket\x20i\x20-\x201.\x20The\
    \x20buckets\x20span\x20the\x20whole\x20range\n\x20of\x20finite\x20values\
    :\x20lower\x20bound\x20of\x20the\x20underflow\x20bucket\x20is\x20-infini\
    ty\x20and\x20the\n\x20upper\x20bound\x20of\x20the\x20overflow\x20bucket\
    \x20is\x20+infinity.\x20The\x20finite\x20buckets\x20are\n\x20so-called\
    \x20because\x20both\x20bounds\x20are\x20finite.\n\n\x0c\n\x05\x04\0\x03\
    \x01\x01\x12\x03C\n\x17\n\xae\x03\n\x06\x04\0\x03\x01\x03\0\x12\x04M\x04\
    V\x05\x1a\x9d\x03\x20Specifies\x20a\x20linear\x20sequence\x20of\x20bucke\
    ts\x20that\x20all\x20have\x20the\x20same\x20width\n\x20(except\x20overfl\
    ow\x20and\x20underflow).\x20Each\x20bucket\x20represents\x20a\x20constan\
    t\n\x20absolute\x20uncertainty\x20on\x20the\x20specific\x20value\x20in\
    \x20the\x20bucket.\n\n\x20There\x20are\x20`num_finite_buckets\x20+\x202`\
    \x20(=\x20N)\x20buckets.\x20Bucket\x20`i`\x20has\x20the\n\x20following\
    \x20boundaries:\n\n\x20\x20\x20\x20Upper\x20bound\x20(0\x20<=\x20i\x20<\
    \x20N-1):\x20\x20\x20\x20\x20offset\x20+\x20(width\x20*\x20i).\n\x20\x20\
    \x20\x20Lower\x20bound\x20(1\x20<=\x20i\x20<\x20N):\x20\x20\x20\x20\x20\
    \x20\x20offset\x20+\x20(width\x20*\x20(i\x20-\x201)).\n\n\x0e\n\x07\x04\
    \0\x03\x01\x03\0\x01\x12\x03M\x0c\x12\n*\n\x08\x04\0\x03\x01\x03\0\x02\0\
    \x12\x03O\x06#\x1a\x19\x20Must\x20be\x20greater\x20than\x200.\n\n\x10\n\
    \t\x04\0\x03\x01\x03\0\x02\0\x05\x12\x03O\x06\x0b\n\x10\n\t\x04\0\x03\
    \x01\x03\0\x02\0\x01\x12\x03O\x0c\x1e\n\x10\n\t\x04\0\x03\x01\x03\0\x02\
    \0\x03\x12\x03O!\"\n*\n\x08\x04\0\x03\x01\x03\0\x02\x01\x12\x03R\x06\x17\
    \x1a\x19\x20Must\x20be\x20greater\x20than\x200.\n\n\x10\n\t\x04\0\x03\
    \x01\x03\0\x02\x01\x05\x12\x03R\x06\x0c\n\x10\n\t\x04\0\x03\x01\x03\0\
    \x02\x01\x01\x12\x03R\r\x12\n\x10\n\t\x04\0\x03\x01\x03\0\x02\x01\x03\
    \x12\x03R\x15\x16\n3\n\x08\x04\0\x03\x01\x03\0\x02\x02\x12\x03U\x06\x18\
    \x1a\"\x20Lower\x20bound\x20of\x20the\x20first\x20bucket.\n\n\x10\n\t\
    \x04\0\x03\x01\x03\0\x02\x02\x05\x12\x03U\x06\x0c\n\x10\n\t\x04\0\x03\
    \x01\x03\0\x02\x02\x01\x12\x03U\r\x13\n\x10\n\t\x04\0\x03\x01\x03\0\x02\
    \x02\x03\x12\x03U\x16\x17\n\xca\x03\n\x06\x04\0\x03\x01\x03\x01\x12\x04a\
    \x04j\x05\x1a\xb9\x03\x20Specifies\x20an\x20exponential\x20sequence\x20o\
    f\x20buckets\x20that\x20have\x20a\x20width\x20that\x20is\n\x20proportion\
    al\x20to\x20the\x20value\x20of\x20the\x20lower\x20bound.\x20Each\x20buck\
    et\x20represents\x20a\n\x20constant\x20relative\x20uncertainty\x20on\x20\
    a\x20specific\x20value\x20in\x20the\x20bucket.\n\n\x20There\x20are\x20`n\
    um_finite_buckets\x20+\x202`\x20(=\x20N)\x20buckets.\x20Bucket\x20`i`\
    \x20has\x20the\n\x20following\x20boundaries:\n\n\x20\x20\x20\x20Upper\
    \x20bound\x20(0\x20<=\x20i\x20<\x20N-1):\x20\x20\x20\x20\x20scale\x20*\
    \x20(growth_factor\x20^\x20i).\n\x20\x20\x20\x20Lower\x20bound\x20(1\x20\
    <=\x20i\x20<\x20N):\x20\x20\x20\x20\x20\x20\x20scale\x20*\x20(growth_fac\
    tor\x20^\x20(i\x20-\x201)).\n\n\x0e\n\x07\x04\0\x03\x01\x03\x01\x01\x12\
    \x03a\x0c\x17\n*\n\x08\x04\0\x03\x01\x03\x01\x02\0\x12\x03c\x06#\x1a\x19\
    \x20Must\x20be\x20greater\x20than\x200.\n\n\x10\n\t\x04\0\x03\x01\x03\
    \x01\x02\0\x05\x12\x03c\x06\x0b\n\x10\n\t\x04\0\x03\x01\x03\x01\x02\0\
    \x01\x12\x03c\x0c\x1e\n\x10\n\t\x04\0\x03\x01\x03\x01\x02\0\x03\x12\x03c\
    !\"\n*\n\x08\x04\0\x03\x01\x03\x01\x02\x01\x12\x03f\x06\x1f\x1a\x19\x20M\
    ust\x20be\x20greater\x20than\x201.\n\n\x10\n\t\x04\0\x03\x01\x03\x01\x02\
    \x01\x05\x12\x03f\x06\x0c\n\x10\n\t\x04\0\x03\x01\x03\x01\x02\x01\x01\
    \x12\x03f\r\x1a\n\x10\n\t\x04\0\x03\x01\x03\x01\x02\x01\x03\x12\x03f\x1d\
    \x1e\n*\n\x08\x04\0\x03\x01\x03\x01\x02\x02\x12\x03i\x06\x17\x1a\x19\x20\
    Must\x20be\x20greater\x20than\x200.\n\n\x10\n\t\x04\0\x03\x01\x03\x01\
    \x02\x02\x05\x12\x03i\x06\x0c\n\x10\n\t\x04\0\x03\x01\x03\x01\x02\x02\
    \x01\x12\x03i\r\x12\n\x10\n\t\x04\0\x03\x01\x03\x01\x02\x02\x03\x12\x03i\
    \x15\x16\n\xd1\x03\n\x06\x04\0\x03\x01\x03\x02\x12\x04w\x04z\x05\x1a\xc0\
    \x03\x20Specifies\x20a\x20set\x20of\x20buckets\x20with\x20arbitrary\x20w\
    idths.\n\n\x20There\x20are\x20`size(bounds)\x20+\x201`\x20(=\x20N)\x20bu\
    ckets.\x20Bucket\x20`i`\x20has\x20the\x20following\n\x20boundaries:\n\n\
    \x20\x20\x20\x20Upper\x20bound\x20(0\x20<=\x20i\x20<\x20N-1):\x20\x20\
    \x20\x20\x20bounds[i]\n\x20\x20\x20\x20Lower\x20bound\x20(1\x20<=\x20i\
    \x20<\x20N);\x20\x20\x20\x20\x20\x20\x20bounds[i\x20-\x201]\n\n\x20The\
    \x20`bounds`\x20field\x20must\x20contain\x20at\x20least\x20one\x20elemen\
    t.\x20If\x20`bounds`\x20has\n\x20only\x20one\x20element,\x20then\x20ther\
    e\x20are\x20no\x20finite\x20buckets,\x20and\x20that\x20single\n\x20eleme\
    nt\x20is\x20the\x20common\x20boundary\x20of\x20the\x20overflow\x20and\
    \x20underflow\x20buckets.\n\n\x0e\n\x07\x04\0\x03\x01\x03\x02\x01\x12\
    \x03w\x0c\x14\n?\n\x08\x04\0\x03\x01\x03\x02\x02\0\x12\x03y\x06!\x1a.\
    \x20The\x20values\x20must\x20be\x20monotonically\x20increasing.\n\n\x10\
    \n\t\x04\0\x03\x01\x03\x02\x02\0\x04\x12\x03y\x06\x0e\n\x10\n\t\x04\0\
    \x03\x01\x03\x02\x02\0\x05\x12\x03y\x0f\x15\n\x10\n\t\x04\0\x03\x01\x03\
    \x02\x02\0\x01\x12\x03y\x16\x1c\n\x10\n\t\x04\0\x03\x01\x03\x02\x02\0\
    \x03\x12\x03y\x1f\x20\nA\n\x06\x04\0\x03\x01\x08\0\x12\x05}\x04\x86\x01\
    \x05\x1a0\x20Exactly\x20one\x20of\x20these\x20three\x20fields\x20must\
    \x20be\x20set.\n\n\x0e\n\x07\x04\0\x03\x01\x08\0\x01\x12\x03}\n\x11\n#\n\
    \x06\x04\0\x03\x01\x02\0\x12\x03\x7f\x06\x20\x1a\x14\x20The\x20linear\
    \x20bucket.\n\n\x0e\n\x07\x04\0\x03\x01\x02\0\x06\x12\x03\x7f\x06\x0c\n\
    \x0e\n\x07\x04\0\x03\x01\x02\0\x01\x12\x03\x7f\r\x1b\n\x0e\n\x07\x04\0\
    \x03\x01\x02\0\x03\x12\x03\x7f\x1e\x1f\n*\n\x06\x04\0\x03\x01\x02\x01\
    \x12\x04\x82\x01\x06*\x1a\x1a\x20The\x20exponential\x20buckets.\n\n\x0f\
    \n\x07\x04\0\x03\x01\x02\x01\x06\x12\x04\x82\x01\x06\x11\n\x0f\n\x07\x04\
    \0\x03\x01\x02\x01\x01\x12\x04\x82\x01\x12%\n\x0f\n\x07\x04\0\x03\x01\
    \x02\x01\x03\x12\x04\x82\x01()\n'\n\x06\x04\0\x03\x01\x02\x02\x12\x04\
    \x85\x01\x06$\x1a\x17\x20The\x20explicit\x20buckets.\n\n\x0f\n\x07\x04\0\
    \x03\x01\x02\x02\x06\x12\x04\x85\x01\x06\x0e\n\x0f\n\x07\x04\0\x03\x01\
    \x02\x02\x01\x12\x04\x85\x01\x0f\x1f\n\x0f\n\x07\x04\0\x03\x01\x02\x02\
    \x03\x12\x04\x85\x01\"#\n\xe9\x02\n\x04\x04\0\x03\x02\x12\x06\x8e\x01\
    \x02\xa2\x01\x03\x1a\xd8\x02\x20Exemplars\x20are\x20example\x20points\
    \x20that\x20may\x20be\x20used\x20to\x20annotate\x20aggregated\n\x20distr\
    ibution\x20values.\x20They\x20are\x20metadata\x20that\x20gives\x20inform\
    ation\x20about\x20a\n\x20particular\x20value\x20added\x20to\x20a\x20Dist\
    ribution\x20bucket,\x20such\x20as\x20a\x20trace\x20ID\x20that\n\x20was\
    \x20active\x20when\x20a\x20value\x20was\x20added.\x20They\x20may\x20cont\
    ain\x20further\x20information,\n\x20such\x20as\x20a\x20example\x20values\
    \x20and\x20timestamps,\x20origin,\x20etc.\n\n\r\n\x05\x04\0\x03\x02\x01\
    \x12\x04\x8e\x01\n\x12\nk\n\x06\x04\0\x03\x02\x02\0\x12\x04\x91\x01\x04\
    \x15\x1a[\x20Value\x20of\x20the\x20exemplar\x20point.\x20This\x20value\
    \x20determines\x20to\x20which\x20bucket\x20the\n\x20exemplar\x20belongs.\
    \n\n\x0f\n\x07\x04\0\x03\x02\x02\0\x05\x12\x04\x91\x01\x04\n\n\x0f\n\x07\
    \x04\0\x03\x02\x02\0\x01\x12\x04\x91\x01\x0b\x10\n\x0f\n\x07\x04\0\x03\
    \x02\x02\0\x03\x12\x04\x91\x01\x13\x14\nE\n\x06\x04\0\x03\x02\x02\x01\
    \x12\x04\x94\x01\x04,\x1a5\x20The\x20observation\x20(sampling)\x20time\
    \x20of\x20the\x20above\x20value.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x06\
    \x12\x04\x94\x01\x04\x1d\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x01\x12\x04\
    \x94\x01\x1e'\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x03\x12\x04\x94\x01*+\n\
    \xb4\x03\n\x06\x04\0\x03\x02\x02\x02\x12\x04\xa1\x01\x041\x1a\xa3\x03\
    \x20Contextual\x20information\x20about\x20the\x20example\x20value.\x20Ex\
    amples\x20are:\n\n\x20\x20\x20Trace:\x20type.googleapis.com/google.monit\
    oring.v3.SpanContext\n\n\x20\x20\x20Literal\x20string:\x20type.googleapi\
    s.com/google.protobuf.StringValue\n\n\x20\x20\x20Labels\x20dropped\x20du\
    ring\x20aggregation:\n\x20\x20\x20\x20\x20type.googleapis.com/google.mon\
    itoring.v3.DroppedLabels\n\n\x20There\x20may\x20be\x20only\x20a\x20singl\
    e\x20attachment\x20of\x20any\x20given\x20message\x20type\x20in\x20a\n\
    \x20single\x20exemplar,\x20and\x20this\x20is\x20enforced\x20by\x20the\
    \x20system.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x02\x04\x12\x04\xa1\x01\x04\
    \x0c\n\x0f\n\x07\x04\0\x03\x02\x02\x02\x06\x12\x04\xa1\x01\r\x20\n\x0f\n\
    \x07\x04\0\x03\x02\x02\x02\x01\x12\x04\xa1\x01!,\n\x0f\n\x07\x04\0\x03\
    \x02\x02\x02\x03\x12\x04\xa1\x01/0\n\xab\x01\n\x04\x04\0\x02\0\x12\x04\
    \xa7\x01\x02\x12\x1a\x9c\x01\x20The\x20number\x20of\x20values\x20in\x20t\
    he\x20population.\x20Must\x20be\x20non-negative.\x20This\x20value\n\x20m\
    ust\x20equal\x20the\x20sum\x20of\x20the\x20values\x20in\x20`bucket_count\
    s`\x20if\x20a\x20histogram\x20is\n\x20provided.\n\n\r\n\x05\x04\0\x02\0\
    \x05\x12\x04\xa7\x01\x02\x07\n\r\n\x05\x04\0\x02\0\x01\x12\x04\xa7\x01\
    \x08\r\n\r\n\x05\x04\0\x02\0\x03\x12\x04\xa7\x01\x10\x11\nv\n\x04\x04\0\
    \x02\x01\x12\x04\xab\x01\x02\x12\x1ah\x20The\x20arithmetic\x20mean\x20of\
    \x20the\x20values\x20in\x20the\x20population.\x20If\x20`count`\x20is\x20\
    zero\n\x20then\x20this\x20field\x20must\x20be\x20zero.\n\n\r\n\x05\x04\0\
    \x02\x01\x05\x12\x04\xab\x01\x02\x08\n\r\n\x05\x04\0\x02\x01\x01\x12\x04\
    \xab\x01\t\r\n\r\n\x05\x04\0\x02\x01\x03\x12\x04\xab\x01\x10\x11\n\xd8\
    \x02\n\x04\x04\0\x02\x02\x12\x04\xb6\x01\x02&\x1a\xc9\x02\x20The\x20sum\
    \x20of\x20squared\x20deviations\x20from\x20the\x20mean\x20of\x20the\x20v\
    alues\x20in\x20the\n\x20population.\x20For\x20values\x20x_i\x20this\x20i\
    s:\n\n\x20\x20\x20\x20\x20Sum[i=1..n]((x_i\x20-\x20mean)^2)\n\n\x20Knuth\
    ,\x20\"The\x20Art\x20of\x20Computer\x20Programming\",\x20Vol.\x202,\x20p\
    age\x20323,\x203rd\x20edition\n\x20describes\x20Welford's\x20method\x20f\
    or\x20accumulating\x20this\x20sum\x20in\x20one\x20pass.\n\n\x20If\x20`co\
    unt`\x20is\x20zero\x20then\x20this\x20field\x20must\x20be\x20zero.\n\n\r\
    \n\x05\x04\0\x02\x02\x05\x12\x04\xb6\x01\x02\x08\n\r\n\x05\x04\0\x02\x02\
    \x01\x12\x04\xb6\x01\t!\n\r\n\x05\x04\0\x02\x02\x03\x12\x04\xb6\x01$%\n\
    \x81\x01\n\x04\x04\0\x02\x03\x12\x04\xba\x01\x02\x12\x1as\x20If\x20speci\
    fied,\x20contains\x20the\x20range\x20of\x20the\x20population\x20values.\
    \x20The\x20field\n\x20must\x20not\x20be\x20present\x20if\x20the\x20`coun\
    t`\x20is\x20zero.\n\n\r\n\x05\x04\0\x02\x03\x06\x12\x04\xba\x01\x02\x07\
    \n\r\n\x05\x04\0\x02\x03\x01\x12\x04\xba\x01\x08\r\n\r\n\x05\x04\0\x02\
    \x03\x03\x12\x04\xba\x01\x10\x11\n\x81\x01\n\x04\x04\0\x02\x04\x12\x04\
    \xbe\x01\x02#\x1as\x20Defines\x20the\x20histogram\x20bucket\x20boundarie\
    s.\x20If\x20the\x20distribution\x20does\x20not\n\x20contain\x20a\x20hist\
    ogram,\x20then\x20omit\x20this\x20field.\n\n\r\n\x05\x04\0\x02\x04\x06\
    \x12\x04\xbe\x01\x02\x0f\n\r\n\x05\x04\0\x02\x04\x01\x12\x04\xbe\x01\x10\
    \x1e\n\r\n\x05\x04\0\x02\x04\x03\x12\x04\xbe\x01!\"\n\xe7\x06\n\x04\x04\
    \0\x02\x05\x12\x04\xcf\x01\x02#\x1a\xd8\x06\x20The\x20number\x20of\x20va\
    lues\x20in\x20each\x20bucket\x20of\x20the\x20histogram,\x20as\x20describ\
    ed\x20in\n\x20`bucket_options`.\x20If\x20the\x20distribution\x20does\x20\
    not\x20have\x20a\x20histogram,\x20then\x20omit\n\x20this\x20field.\x20If\
    \x20there\x20is\x20a\x20histogram,\x20then\x20the\x20sum\x20of\x20the\
    \x20values\x20in\n\x20`bucket_counts`\x20must\x20equal\x20the\x20value\
    \x20in\x20the\x20`count`\x20field\x20of\x20the\n\x20distribution.\n\n\
    \x20If\x20present,\x20`bucket_counts`\x20should\x20contain\x20N\x20value\
    s,\x20where\x20N\x20is\x20the\x20number\n\x20of\x20buckets\x20specified\
    \x20in\x20`bucket_options`.\x20If\x20you\x20supply\x20fewer\x20than\x20N\
    \n\x20values,\x20the\x20remaining\x20values\x20are\x20assumed\x20to\x20b\
    e\x200.\n\n\x20The\x20order\x20of\x20the\x20values\x20in\x20`bucket_coun\
    ts`\x20follows\x20the\x20bucket\x20numbering\n\x20schemes\x20described\
    \x20for\x20the\x20three\x20bucket\x20types.\x20The\x20first\x20value\x20\
    must\x20be\x20the\n\x20count\x20for\x20the\x20underflow\x20bucket\x20(nu\
    mber\x200).\x20The\x20next\x20N-2\x20values\x20are\x20the\n\x20counts\
    \x20for\x20the\x20finite\x20buckets\x20(number\x201\x20through\x20N-2).\
    \x20The\x20N'th\x20value\x20in\n\x20`bucket_counts`\x20is\x20the\x20coun\
    t\x20for\x20the\x20overflow\x20bucket\x20(number\x20N-1).\n\n\r\n\x05\
    \x04\0\x02\x05\x04\x12\x04\xcf\x01\x02\n\n\r\n\x05\x04\0\x02\x05\x05\x12\
    \x04\xcf\x01\x0b\x10\n\r\n\x05\x04\0\x02\x05\x01\x12\x04\xcf\x01\x11\x1e\
    \n\r\n\x05\x04\0\x02\x05\x03\x12\x04\xcf\x01!\"\n=\n\x04\x04\0\x02\x06\
    \x12\x04\xd2\x01\x02#\x1a/\x20Must\x20be\x20in\x20increasing\x20order\
    \x20of\x20`value`\x20field.\n\n\r\n\x05\x04\0\x02\x06\x04\x12\x04\xd2\
    \x01\x02\n\n\r\n\x05\x04\0\x02\x06\x06\x12\x04\xd2\x01\x0b\x13\n\r\n\x05\
    \x04\0\x02\x06\x01\x12\x04\xd2\x01\x14\x1d\n\r\n\x05\x04\0\x02\x06\x03\
    \x12\x04\xd2\x01\x20\"b\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()
    })
}