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/pubsub/v1beta2/pubsub.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 Topic {
    // message fields
    pub name: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl Topic {
    pub fn new() -> Topic {
        ::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())
    }
}

impl ::protobuf::Message for Topic {
    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_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                _ => {
                    ::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);
        }
        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)?;
        }
        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() -> Topic {
        Topic::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: &Topic| { &m.name },
                |m: &mut Topic| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Topic>(
                "Topic",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PubsubMessage {
    // message fields
    pub data: ::std::vec::Vec<u8>,
    pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    pub message_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // bytes data = 1;


    pub fn get_data(&self) -> &[u8] {
        &self.data
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

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

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

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

    // repeated .google.pubsub.v1beta2.PubsubMessage.AttributesEntry attributes = 2;


    pub fn get_attributes(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &self.attributes
    }
    pub fn clear_attributes(&mut self) {
        self.attributes.clear();
    }

    // Param is passed by value, moved
    pub fn set_attributes(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
        self.attributes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_attributes(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &mut self.attributes
    }

    // Take field
    pub fn take_attributes(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        ::std::mem::replace(&mut self.attributes, ::std::collections::HashMap::new())
    }

    // string message_id = 3;


    pub fn get_message_id(&self) -> &str {
        &self.message_id
    }
    pub fn clear_message_id(&mut self) {
        self.message_id.clear();
    }

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

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

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

impl ::protobuf::Message for PubsubMessage {
    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_singular_proto3_bytes_into(wire_type, is, &mut self.data)?;
                },
                2 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.attributes)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.message_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;
        if !self.data.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.data);
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes);
        if !self.message_id.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.message_id);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.data.is_empty() {
            os.write_bytes(1, &self.data)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes, os)?;
        if !self.message_id.is_empty() {
            os.write_string(3, &self.message_id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> PubsubMessage {
        PubsubMessage::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::ProtobufTypeBytes>(
                "data",
                |m: &PubsubMessage| { &m.data },
                |m: &mut PubsubMessage| { &mut m.data },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
                "attributes",
                |m: &PubsubMessage| { &m.attributes },
                |m: &mut PubsubMessage| { &mut m.attributes },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "message_id",
                |m: &PubsubMessage| { &m.message_id },
                |m: &mut PubsubMessage| { &mut m.message_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PubsubMessage>(
                "PubsubMessage",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for PubsubMessage {
    fn clear(&mut self) {
        self.data.clear();
        self.attributes.clear();
        self.message_id.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetTopicRequest {
    // message fields
    pub topic: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string topic = 1;


    pub fn get_topic(&self) -> &str {
        &self.topic
    }
    pub fn clear_topic(&mut self) {
        self.topic.clear();
    }

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

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

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

impl ::protobuf::Message for GetTopicRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.topic)?;
                },
                _ => {
                    ::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.topic.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.topic);
        }
        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.topic.is_empty() {
            os.write_string(1, &self.topic)?;
        }
        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() -> GetTopicRequest {
        GetTopicRequest::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>(
                "topic",
                |m: &GetTopicRequest| { &m.topic },
                |m: &mut GetTopicRequest| { &mut m.topic },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetTopicRequest>(
                "GetTopicRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PublishRequest {
    // message fields
    pub topic: ::std::string::String,
    pub messages: ::protobuf::RepeatedField<PubsubMessage>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string topic = 1;


    pub fn get_topic(&self) -> &str {
        &self.topic
    }
    pub fn clear_topic(&mut self) {
        self.topic.clear();
    }

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

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

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

    // repeated .google.pubsub.v1beta2.PubsubMessage messages = 2;


    pub fn get_messages(&self) -> &[PubsubMessage] {
        &self.messages
    }
    pub fn clear_messages(&mut self) {
        self.messages.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_messages(&mut self) -> &mut ::protobuf::RepeatedField<PubsubMessage> {
        &mut self.messages
    }

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

impl ::protobuf::Message for PublishRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.messages {
            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.topic)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.messages)?;
                },
                _ => {
                    ::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.topic.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.topic);
        }
        for value in &self.messages {
            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.topic.is_empty() {
            os.write_string(1, &self.topic)?;
        }
        for v in &self.messages {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> PublishRequest {
        PublishRequest::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>(
                "topic",
                |m: &PublishRequest| { &m.topic },
                |m: &mut PublishRequest| { &mut m.topic },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PubsubMessage>>(
                "messages",
                |m: &PublishRequest| { &m.messages },
                |m: &mut PublishRequest| { &mut m.messages },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PublishRequest>(
                "PublishRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for PublishRequest {
    fn clear(&mut self) {
        self.topic.clear();
        self.messages.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PublishResponse {
    // message fields
    pub message_ids: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated string message_ids = 1;


    pub fn get_message_ids(&self) -> &[::std::string::String] {
        &self.message_ids
    }
    pub fn clear_message_ids(&mut self) {
        self.message_ids.clear();
    }

    // Param is passed by value, moved
    pub fn set_message_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.message_ids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_message_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.message_ids
    }

    // Take field
    pub fn take_message_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.message_ids, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for PublishResponse {
    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_string_into(wire_type, is, &mut self.message_ids)?;
                },
                _ => {
                    ::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.message_ids {
            my_size += ::protobuf::rt::string_size(1, &value);
        };
        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.message_ids {
            os.write_string(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() -> PublishResponse {
        PublishResponse::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::ProtobufTypeString>(
                "message_ids",
                |m: &PublishResponse| { &m.message_ids },
                |m: &mut PublishResponse| { &mut m.message_ids },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PublishResponse>(
                "PublishResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListTopicsRequest {
    // message fields
    pub project: ::std::string::String,
    pub page_size: i32,
    pub page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string project = 1;


    pub fn get_project(&self) -> &str {
        &self.project
    }
    pub fn clear_project(&mut self) {
        self.project.clear();
    }

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

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

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

    // int32 page_size = 2;


    pub fn get_page_size(&self) -> i32 {
        self.page_size
    }
    pub fn clear_page_size(&mut self) {
        self.page_size = 0;
    }

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

    // string page_token = 3;


    pub fn get_page_token(&self) -> &str {
        &self.page_token
    }
    pub fn clear_page_token(&mut self) {
        self.page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListTopicsRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.project)?;
                },
                2 => {
                    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.page_size = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?;
                },
                _ => {
                    ::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.project.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.project);
        }
        if self.page_size != 0 {
            my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.page_token);
        }
        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.project.is_empty() {
            os.write_string(1, &self.project)?;
        }
        if self.page_size != 0 {
            os.write_int32(2, self.page_size)?;
        }
        if !self.page_token.is_empty() {
            os.write_string(3, &self.page_token)?;
        }
        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() -> ListTopicsRequest {
        ListTopicsRequest::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>(
                "project",
                |m: &ListTopicsRequest| { &m.project },
                |m: &mut ListTopicsRequest| { &mut m.project },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListTopicsRequest| { &m.page_size },
                |m: &mut ListTopicsRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListTopicsRequest| { &m.page_token },
                |m: &mut ListTopicsRequest| { &mut m.page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListTopicsRequest>(
                "ListTopicsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListTopicsRequest {
    fn clear(&mut self) {
        self.project.clear();
        self.page_size = 0;
        self.page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListTopicsResponse {
    // message fields
    pub topics: ::protobuf::RepeatedField<Topic>,
    pub next_page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .google.pubsub.v1beta2.Topic topics = 1;


    pub fn get_topics(&self) -> &[Topic] {
        &self.topics
    }
    pub fn clear_topics(&mut self) {
        self.topics.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_topics(&mut self) -> &mut ::protobuf::RepeatedField<Topic> {
        &mut self.topics
    }

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

    // string next_page_token = 2;


    pub fn get_next_page_token(&self) -> &str {
        &self.next_page_token
    }
    pub fn clear_next_page_token(&mut self) {
        self.next_page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListTopicsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.topics {
            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.topics)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
                },
                _ => {
                    ::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.topics {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if !self.next_page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.next_page_token);
        }
        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.topics {
            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.next_page_token.is_empty() {
            os.write_string(2, &self.next_page_token)?;
        }
        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() -> ListTopicsResponse {
        ListTopicsResponse::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<Topic>>(
                "topics",
                |m: &ListTopicsResponse| { &m.topics },
                |m: &mut ListTopicsResponse| { &mut m.topics },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListTopicsResponse| { &m.next_page_token },
                |m: &mut ListTopicsResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListTopicsResponse>(
                "ListTopicsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListTopicsResponse {
    fn clear(&mut self) {
        self.topics.clear();
        self.next_page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListTopicSubscriptionsRequest {
    // message fields
    pub topic: ::std::string::String,
    pub page_size: i32,
    pub page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string topic = 1;


    pub fn get_topic(&self) -> &str {
        &self.topic
    }
    pub fn clear_topic(&mut self) {
        self.topic.clear();
    }

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

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

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

    // int32 page_size = 2;


    pub fn get_page_size(&self) -> i32 {
        self.page_size
    }
    pub fn clear_page_size(&mut self) {
        self.page_size = 0;
    }

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

    // string page_token = 3;


    pub fn get_page_token(&self) -> &str {
        &self.page_token
    }
    pub fn clear_page_token(&mut self) {
        self.page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListTopicSubscriptionsRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.topic)?;
                },
                2 => {
                    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.page_size = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?;
                },
                _ => {
                    ::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.topic.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.topic);
        }
        if self.page_size != 0 {
            my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.page_token);
        }
        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.topic.is_empty() {
            os.write_string(1, &self.topic)?;
        }
        if self.page_size != 0 {
            os.write_int32(2, self.page_size)?;
        }
        if !self.page_token.is_empty() {
            os.write_string(3, &self.page_token)?;
        }
        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() -> ListTopicSubscriptionsRequest {
        ListTopicSubscriptionsRequest::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>(
                "topic",
                |m: &ListTopicSubscriptionsRequest| { &m.topic },
                |m: &mut ListTopicSubscriptionsRequest| { &mut m.topic },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListTopicSubscriptionsRequest| { &m.page_size },
                |m: &mut ListTopicSubscriptionsRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListTopicSubscriptionsRequest| { &m.page_token },
                |m: &mut ListTopicSubscriptionsRequest| { &mut m.page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListTopicSubscriptionsRequest>(
                "ListTopicSubscriptionsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListTopicSubscriptionsRequest {
    fn clear(&mut self) {
        self.topic.clear();
        self.page_size = 0;
        self.page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListTopicSubscriptionsResponse {
    // message fields
    pub subscriptions: ::protobuf::RepeatedField<::std::string::String>,
    pub next_page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated string subscriptions = 1;


    pub fn get_subscriptions(&self) -> &[::std::string::String] {
        &self.subscriptions
    }
    pub fn clear_subscriptions(&mut self) {
        self.subscriptions.clear();
    }

    // Param is passed by value, moved
    pub fn set_subscriptions(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.subscriptions = v;
    }

    // Mutable pointer to the field.
    pub fn mut_subscriptions(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.subscriptions
    }

    // Take field
    pub fn take_subscriptions(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.subscriptions, ::protobuf::RepeatedField::new())
    }

    // string next_page_token = 2;


    pub fn get_next_page_token(&self) -> &str {
        &self.next_page_token
    }
    pub fn clear_next_page_token(&mut self) {
        self.next_page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListTopicSubscriptionsResponse {
    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_string_into(wire_type, is, &mut self.subscriptions)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
                },
                _ => {
                    ::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.subscriptions {
            my_size += ::protobuf::rt::string_size(1, &value);
        };
        if !self.next_page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.next_page_token);
        }
        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.subscriptions {
            os.write_string(1, &v)?;
        };
        if !self.next_page_token.is_empty() {
            os.write_string(2, &self.next_page_token)?;
        }
        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() -> ListTopicSubscriptionsResponse {
        ListTopicSubscriptionsResponse::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::ProtobufTypeString>(
                "subscriptions",
                |m: &ListTopicSubscriptionsResponse| { &m.subscriptions },
                |m: &mut ListTopicSubscriptionsResponse| { &mut m.subscriptions },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListTopicSubscriptionsResponse| { &m.next_page_token },
                |m: &mut ListTopicSubscriptionsResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListTopicSubscriptionsResponse>(
                "ListTopicSubscriptionsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListTopicSubscriptionsResponse {
    fn clear(&mut self) {
        self.subscriptions.clear();
        self.next_page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct DeleteTopicRequest {
    // message fields
    pub topic: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string topic = 1;


    pub fn get_topic(&self) -> &str {
        &self.topic
    }
    pub fn clear_topic(&mut self) {
        self.topic.clear();
    }

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

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

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

impl ::protobuf::Message for DeleteTopicRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.topic)?;
                },
                _ => {
                    ::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.topic.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.topic);
        }
        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.topic.is_empty() {
            os.write_string(1, &self.topic)?;
        }
        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() -> DeleteTopicRequest {
        DeleteTopicRequest::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>(
                "topic",
                |m: &DeleteTopicRequest| { &m.topic },
                |m: &mut DeleteTopicRequest| { &mut m.topic },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteTopicRequest>(
                "DeleteTopicRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct Subscription {
    // message fields
    pub name: ::std::string::String,
    pub topic: ::std::string::String,
    pub push_config: ::protobuf::SingularPtrField<PushConfig>,
    pub ack_deadline_seconds: i32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl Subscription {
    pub fn new() -> Subscription {
        ::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 topic = 2;


    pub fn get_topic(&self) -> &str {
        &self.topic
    }
    pub fn clear_topic(&mut self) {
        self.topic.clear();
    }

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

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

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

    // .google.pubsub.v1beta2.PushConfig push_config = 4;


    pub fn get_push_config(&self) -> &PushConfig {
        self.push_config.as_ref().unwrap_or_else(|| <PushConfig as ::protobuf::Message>::default_instance())
    }
    pub fn clear_push_config(&mut self) {
        self.push_config.clear();
    }

    pub fn has_push_config(&self) -> bool {
        self.push_config.is_some()
    }

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

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

    // Take field
    pub fn take_push_config(&mut self) -> PushConfig {
        self.push_config.take().unwrap_or_else(|| PushConfig::new())
    }

    // int32 ack_deadline_seconds = 5;


    pub fn get_ack_deadline_seconds(&self) -> i32 {
        self.ack_deadline_seconds
    }
    pub fn clear_ack_deadline_seconds(&mut self) {
        self.ack_deadline_seconds = 0;
    }

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

impl ::protobuf::Message for Subscription {
    fn is_initialized(&self) -> bool {
        for v in &self.push_config {
            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.topic)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.push_config)?;
                },
                5 => {
                    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.ack_deadline_seconds = 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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if !self.topic.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.topic);
        }
        if let Some(ref v) = self.push_config.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.ack_deadline_seconds != 0 {
            my_size += ::protobuf::rt::value_size(5, self.ack_deadline_seconds, ::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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if !self.topic.is_empty() {
            os.write_string(2, &self.topic)?;
        }
        if let Some(ref v) = self.push_config.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 self.ack_deadline_seconds != 0 {
            os.write_int32(5, self.ack_deadline_seconds)?;
        }
        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() -> Subscription {
        Subscription::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: &Subscription| { &m.name },
                |m: &mut Subscription| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "topic",
                |m: &Subscription| { &m.topic },
                |m: &mut Subscription| { &mut m.topic },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PushConfig>>(
                "push_config",
                |m: &Subscription| { &m.push_config },
                |m: &mut Subscription| { &mut m.push_config },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "ack_deadline_seconds",
                |m: &Subscription| { &m.ack_deadline_seconds },
                |m: &mut Subscription| { &mut m.ack_deadline_seconds },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Subscription>(
                "Subscription",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for Subscription {
    fn clear(&mut self) {
        self.name.clear();
        self.topic.clear();
        self.push_config.clear();
        self.ack_deadline_seconds = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PushConfig {
    // message fields
    pub push_endpoint: ::std::string::String,
    pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string push_endpoint = 1;


    pub fn get_push_endpoint(&self) -> &str {
        &self.push_endpoint
    }
    pub fn clear_push_endpoint(&mut self) {
        self.push_endpoint.clear();
    }

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

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

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

    // repeated .google.pubsub.v1beta2.PushConfig.AttributesEntry attributes = 2;


    pub fn get_attributes(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &self.attributes
    }
    pub fn clear_attributes(&mut self) {
        self.attributes.clear();
    }

    // Param is passed by value, moved
    pub fn set_attributes(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
        self.attributes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_attributes(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &mut self.attributes
    }

    // Take field
    pub fn take_attributes(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        ::std::mem::replace(&mut self.attributes, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for PushConfig {
    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_singular_proto3_string_into(wire_type, is, &mut self.push_endpoint)?;
                },
                2 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.attributes)?;
                },
                _ => {
                    ::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.push_endpoint.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.push_endpoint);
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes);
        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.push_endpoint.is_empty() {
            os.write_string(1, &self.push_endpoint)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes, 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() -> PushConfig {
        PushConfig::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>(
                "push_endpoint",
                |m: &PushConfig| { &m.push_endpoint },
                |m: &mut PushConfig| { &mut m.push_endpoint },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
                "attributes",
                |m: &PushConfig| { &m.attributes },
                |m: &mut PushConfig| { &mut m.attributes },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PushConfig>(
                "PushConfig",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for PushConfig {
    fn clear(&mut self) {
        self.push_endpoint.clear();
        self.attributes.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ReceivedMessage {
    // message fields
    pub ack_id: ::std::string::String,
    pub message: ::protobuf::SingularPtrField<PubsubMessage>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string ack_id = 1;


    pub fn get_ack_id(&self) -> &str {
        &self.ack_id
    }
    pub fn clear_ack_id(&mut self) {
        self.ack_id.clear();
    }

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

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

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

    // .google.pubsub.v1beta2.PubsubMessage message = 2;


    pub fn get_message(&self) -> &PubsubMessage {
        self.message.as_ref().unwrap_or_else(|| <PubsubMessage as ::protobuf::Message>::default_instance())
    }
    pub fn clear_message(&mut self) {
        self.message.clear();
    }

    pub fn has_message(&self) -> bool {
        self.message.is_some()
    }

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

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

    // Take field
    pub fn take_message(&mut self) -> PubsubMessage {
        self.message.take().unwrap_or_else(|| PubsubMessage::new())
    }
}

impl ::protobuf::Message for ReceivedMessage {
    fn is_initialized(&self) -> bool {
        for v in &self.message {
            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.ack_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.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.ack_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.ack_id);
        }
        if let Some(ref v) = self.message.as_ref() {
            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.ack_id.is_empty() {
            os.write_string(1, &self.ack_id)?;
        }
        if let Some(ref v) = self.message.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)?;
        }
        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() -> ReceivedMessage {
        ReceivedMessage::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>(
                "ack_id",
                |m: &ReceivedMessage| { &m.ack_id },
                |m: &mut ReceivedMessage| { &mut m.ack_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PubsubMessage>>(
                "message",
                |m: &ReceivedMessage| { &m.message },
                |m: &mut ReceivedMessage| { &mut m.message },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ReceivedMessage>(
                "ReceivedMessage",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ReceivedMessage {
    fn clear(&mut self) {
        self.ack_id.clear();
        self.message.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetSubscriptionRequest {
    // message fields
    pub subscription: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string subscription = 1;


    pub fn get_subscription(&self) -> &str {
        &self.subscription
    }
    pub fn clear_subscription(&mut self) {
        self.subscription.clear();
    }

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

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

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

impl ::protobuf::Message for GetSubscriptionRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.subscription)?;
                },
                _ => {
                    ::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.subscription.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.subscription);
        }
        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.subscription.is_empty() {
            os.write_string(1, &self.subscription)?;
        }
        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() -> GetSubscriptionRequest {
        GetSubscriptionRequest::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>(
                "subscription",
                |m: &GetSubscriptionRequest| { &m.subscription },
                |m: &mut GetSubscriptionRequest| { &mut m.subscription },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetSubscriptionRequest>(
                "GetSubscriptionRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListSubscriptionsRequest {
    // message fields
    pub project: ::std::string::String,
    pub page_size: i32,
    pub page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string project = 1;


    pub fn get_project(&self) -> &str {
        &self.project
    }
    pub fn clear_project(&mut self) {
        self.project.clear();
    }

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

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

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

    // int32 page_size = 2;


    pub fn get_page_size(&self) -> i32 {
        self.page_size
    }
    pub fn clear_page_size(&mut self) {
        self.page_size = 0;
    }

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

    // string page_token = 3;


    pub fn get_page_token(&self) -> &str {
        &self.page_token
    }
    pub fn clear_page_token(&mut self) {
        self.page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListSubscriptionsRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.project)?;
                },
                2 => {
                    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.page_size = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?;
                },
                _ => {
                    ::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.project.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.project);
        }
        if self.page_size != 0 {
            my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.page_token);
        }
        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.project.is_empty() {
            os.write_string(1, &self.project)?;
        }
        if self.page_size != 0 {
            os.write_int32(2, self.page_size)?;
        }
        if !self.page_token.is_empty() {
            os.write_string(3, &self.page_token)?;
        }
        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() -> ListSubscriptionsRequest {
        ListSubscriptionsRequest::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>(
                "project",
                |m: &ListSubscriptionsRequest| { &m.project },
                |m: &mut ListSubscriptionsRequest| { &mut m.project },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListSubscriptionsRequest| { &m.page_size },
                |m: &mut ListSubscriptionsRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListSubscriptionsRequest| { &m.page_token },
                |m: &mut ListSubscriptionsRequest| { &mut m.page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSubscriptionsRequest>(
                "ListSubscriptionsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListSubscriptionsRequest {
    fn clear(&mut self) {
        self.project.clear();
        self.page_size = 0;
        self.page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListSubscriptionsResponse {
    // message fields
    pub subscriptions: ::protobuf::RepeatedField<Subscription>,
    pub next_page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .google.pubsub.v1beta2.Subscription subscriptions = 1;


    pub fn get_subscriptions(&self) -> &[Subscription] {
        &self.subscriptions
    }
    pub fn clear_subscriptions(&mut self) {
        self.subscriptions.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_subscriptions(&mut self) -> &mut ::protobuf::RepeatedField<Subscription> {
        &mut self.subscriptions
    }

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

    // string next_page_token = 2;


    pub fn get_next_page_token(&self) -> &str {
        &self.next_page_token
    }
    pub fn clear_next_page_token(&mut self) {
        self.next_page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListSubscriptionsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.subscriptions {
            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.subscriptions)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
                },
                _ => {
                    ::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.subscriptions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if !self.next_page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.next_page_token);
        }
        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.subscriptions {
            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.next_page_token.is_empty() {
            os.write_string(2, &self.next_page_token)?;
        }
        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() -> ListSubscriptionsResponse {
        ListSubscriptionsResponse::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<Subscription>>(
                "subscriptions",
                |m: &ListSubscriptionsResponse| { &m.subscriptions },
                |m: &mut ListSubscriptionsResponse| { &mut m.subscriptions },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListSubscriptionsResponse| { &m.next_page_token },
                |m: &mut ListSubscriptionsResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSubscriptionsResponse>(
                "ListSubscriptionsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListSubscriptionsResponse {
    fn clear(&mut self) {
        self.subscriptions.clear();
        self.next_page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct DeleteSubscriptionRequest {
    // message fields
    pub subscription: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string subscription = 1;


    pub fn get_subscription(&self) -> &str {
        &self.subscription
    }
    pub fn clear_subscription(&mut self) {
        self.subscription.clear();
    }

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

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

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

impl ::protobuf::Message for DeleteSubscriptionRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.subscription)?;
                },
                _ => {
                    ::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.subscription.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.subscription);
        }
        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.subscription.is_empty() {
            os.write_string(1, &self.subscription)?;
        }
        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() -> DeleteSubscriptionRequest {
        DeleteSubscriptionRequest::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>(
                "subscription",
                |m: &DeleteSubscriptionRequest| { &m.subscription },
                |m: &mut DeleteSubscriptionRequest| { &mut m.subscription },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteSubscriptionRequest>(
                "DeleteSubscriptionRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ModifyPushConfigRequest {
    // message fields
    pub subscription: ::std::string::String,
    pub push_config: ::protobuf::SingularPtrField<PushConfig>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string subscription = 1;


    pub fn get_subscription(&self) -> &str {
        &self.subscription
    }
    pub fn clear_subscription(&mut self) {
        self.subscription.clear();
    }

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

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

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

    // .google.pubsub.v1beta2.PushConfig push_config = 2;


    pub fn get_push_config(&self) -> &PushConfig {
        self.push_config.as_ref().unwrap_or_else(|| <PushConfig as ::protobuf::Message>::default_instance())
    }
    pub fn clear_push_config(&mut self) {
        self.push_config.clear();
    }

    pub fn has_push_config(&self) -> bool {
        self.push_config.is_some()
    }

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

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

    // Take field
    pub fn take_push_config(&mut self) -> PushConfig {
        self.push_config.take().unwrap_or_else(|| PushConfig::new())
    }
}

impl ::protobuf::Message for ModifyPushConfigRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.push_config {
            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.subscription)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.push_config)?;
                },
                _ => {
                    ::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.subscription.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.subscription);
        }
        if let Some(ref v) = self.push_config.as_ref() {
            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.subscription.is_empty() {
            os.write_string(1, &self.subscription)?;
        }
        if let Some(ref v) = self.push_config.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)?;
        }
        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() -> ModifyPushConfigRequest {
        ModifyPushConfigRequest::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>(
                "subscription",
                |m: &ModifyPushConfigRequest| { &m.subscription },
                |m: &mut ModifyPushConfigRequest| { &mut m.subscription },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PushConfig>>(
                "push_config",
                |m: &ModifyPushConfigRequest| { &m.push_config },
                |m: &mut ModifyPushConfigRequest| { &mut m.push_config },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ModifyPushConfigRequest>(
                "ModifyPushConfigRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ModifyPushConfigRequest {
    fn clear(&mut self) {
        self.subscription.clear();
        self.push_config.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PullRequest {
    // message fields
    pub subscription: ::std::string::String,
    pub return_immediately: bool,
    pub max_messages: i32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string subscription = 1;


    pub fn get_subscription(&self) -> &str {
        &self.subscription
    }
    pub fn clear_subscription(&mut self) {
        self.subscription.clear();
    }

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

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

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

    // bool return_immediately = 2;


    pub fn get_return_immediately(&self) -> bool {
        self.return_immediately
    }
    pub fn clear_return_immediately(&mut self) {
        self.return_immediately = false;
    }

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

    // int32 max_messages = 3;


    pub fn get_max_messages(&self) -> i32 {
        self.max_messages
    }
    pub fn clear_max_messages(&mut self) {
        self.max_messages = 0;
    }

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

impl ::protobuf::Message for PullRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.subscription)?;
                },
                2 => {
                    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.return_immediately = tmp;
                },
                3 => {
                    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.max_messages = 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.subscription.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.subscription);
        }
        if self.return_immediately != false {
            my_size += 2;
        }
        if self.max_messages != 0 {
            my_size += ::protobuf::rt::value_size(3, self.max_messages, ::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.subscription.is_empty() {
            os.write_string(1, &self.subscription)?;
        }
        if self.return_immediately != false {
            os.write_bool(2, self.return_immediately)?;
        }
        if self.max_messages != 0 {
            os.write_int32(3, self.max_messages)?;
        }
        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() -> PullRequest {
        PullRequest::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>(
                "subscription",
                |m: &PullRequest| { &m.subscription },
                |m: &mut PullRequest| { &mut m.subscription },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "return_immediately",
                |m: &PullRequest| { &m.return_immediately },
                |m: &mut PullRequest| { &mut m.return_immediately },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "max_messages",
                |m: &PullRequest| { &m.max_messages },
                |m: &mut PullRequest| { &mut m.max_messages },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PullRequest>(
                "PullRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for PullRequest {
    fn clear(&mut self) {
        self.subscription.clear();
        self.return_immediately = false;
        self.max_messages = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PullResponse {
    // message fields
    pub received_messages: ::protobuf::RepeatedField<ReceivedMessage>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .google.pubsub.v1beta2.ReceivedMessage received_messages = 1;


    pub fn get_received_messages(&self) -> &[ReceivedMessage] {
        &self.received_messages
    }
    pub fn clear_received_messages(&mut self) {
        self.received_messages.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_received_messages(&mut self) -> &mut ::protobuf::RepeatedField<ReceivedMessage> {
        &mut self.received_messages
    }

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

impl ::protobuf::Message for PullResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.received_messages {
            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.received_messages)?;
                },
                _ => {
                    ::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.received_messages {
            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.received_messages {
            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() -> PullResponse {
        PullResponse::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<ReceivedMessage>>(
                "received_messages",
                |m: &PullResponse| { &m.received_messages },
                |m: &mut PullResponse| { &mut m.received_messages },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PullResponse>(
                "PullResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ModifyAckDeadlineRequest {
    // message fields
    pub subscription: ::std::string::String,
    pub ack_id: ::std::string::String,
    pub ack_deadline_seconds: i32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string subscription = 1;


    pub fn get_subscription(&self) -> &str {
        &self.subscription
    }
    pub fn clear_subscription(&mut self) {
        self.subscription.clear();
    }

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

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

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

    // string ack_id = 2;


    pub fn get_ack_id(&self) -> &str {
        &self.ack_id
    }
    pub fn clear_ack_id(&mut self) {
        self.ack_id.clear();
    }

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

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

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

    // int32 ack_deadline_seconds = 3;


    pub fn get_ack_deadline_seconds(&self) -> i32 {
        self.ack_deadline_seconds
    }
    pub fn clear_ack_deadline_seconds(&mut self) {
        self.ack_deadline_seconds = 0;
    }

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

impl ::protobuf::Message for ModifyAckDeadlineRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.subscription)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.ack_id)?;
                },
                3 => {
                    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.ack_deadline_seconds = 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.subscription.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.subscription);
        }
        if !self.ack_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.ack_id);
        }
        if self.ack_deadline_seconds != 0 {
            my_size += ::protobuf::rt::value_size(3, self.ack_deadline_seconds, ::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.subscription.is_empty() {
            os.write_string(1, &self.subscription)?;
        }
        if !self.ack_id.is_empty() {
            os.write_string(2, &self.ack_id)?;
        }
        if self.ack_deadline_seconds != 0 {
            os.write_int32(3, self.ack_deadline_seconds)?;
        }
        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() -> ModifyAckDeadlineRequest {
        ModifyAckDeadlineRequest::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>(
                "subscription",
                |m: &ModifyAckDeadlineRequest| { &m.subscription },
                |m: &mut ModifyAckDeadlineRequest| { &mut m.subscription },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "ack_id",
                |m: &ModifyAckDeadlineRequest| { &m.ack_id },
                |m: &mut ModifyAckDeadlineRequest| { &mut m.ack_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "ack_deadline_seconds",
                |m: &ModifyAckDeadlineRequest| { &m.ack_deadline_seconds },
                |m: &mut ModifyAckDeadlineRequest| { &mut m.ack_deadline_seconds },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ModifyAckDeadlineRequest>(
                "ModifyAckDeadlineRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ModifyAckDeadlineRequest {
    fn clear(&mut self) {
        self.subscription.clear();
        self.ack_id.clear();
        self.ack_deadline_seconds = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct AcknowledgeRequest {
    // message fields
    pub subscription: ::std::string::String,
    pub ack_ids: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string subscription = 1;


    pub fn get_subscription(&self) -> &str {
        &self.subscription
    }
    pub fn clear_subscription(&mut self) {
        self.subscription.clear();
    }

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

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

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

    // repeated string ack_ids = 2;


    pub fn get_ack_ids(&self) -> &[::std::string::String] {
        &self.ack_ids
    }
    pub fn clear_ack_ids(&mut self) {
        self.ack_ids.clear();
    }

    // Param is passed by value, moved
    pub fn set_ack_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.ack_ids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_ack_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.ack_ids
    }

    // Take field
    pub fn take_ack_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.ack_ids, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for AcknowledgeRequest {
    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_singular_proto3_string_into(wire_type, is, &mut self.subscription)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.ack_ids)?;
                },
                _ => {
                    ::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.subscription.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.subscription);
        }
        for value in &self.ack_ids {
            my_size += ::protobuf::rt::string_size(2, &value);
        };
        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.subscription.is_empty() {
            os.write_string(1, &self.subscription)?;
        }
        for v in &self.ack_ids {
            os.write_string(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() -> AcknowledgeRequest {
        AcknowledgeRequest::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>(
                "subscription",
                |m: &AcknowledgeRequest| { &m.subscription },
                |m: &mut AcknowledgeRequest| { &mut m.subscription },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "ack_ids",
                |m: &AcknowledgeRequest| { &m.ack_ids },
                |m: &mut AcknowledgeRequest| { &mut m.ack_ids },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<AcknowledgeRequest>(
                "AcknowledgeRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for AcknowledgeRequest {
    fn clear(&mut self) {
        self.subscription.clear();
        self.ack_ids.clear();
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\"google/pubsub/v1beta2/pubsub.proto\x12\x15google.pubsub.v1beta2\x1a\
    \x1bgoogle/protobuf/empty.proto\"\x1b\n\x05Topic\x12\x12\n\x04name\x18\
    \x01\x20\x01(\tR\x04name\"\xd7\x01\n\rPubsubMessage\x12\x12\n\x04data\
    \x18\x01\x20\x01(\x0cR\x04data\x12T\n\nattributes\x18\x02\x20\x03(\x0b24\
    .google.pubsub.v1beta2.PubsubMessage.AttributesEntryR\nattributes\x12\
    \x1d\n\nmessage_id\x18\x03\x20\x01(\tR\tmessageId\x1a=\n\x0fAttributesEn\
    try\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\
    \x02\x20\x01(\tR\x05value:\x028\x01\"'\n\x0fGetTopicRequest\x12\x14\n\
    \x05topic\x18\x01\x20\x01(\tR\x05topic\"h\n\x0ePublishRequest\x12\x14\n\
    \x05topic\x18\x01\x20\x01(\tR\x05topic\x12@\n\x08messages\x18\x02\x20\
    \x03(\x0b2$.google.pubsub.v1beta2.PubsubMessageR\x08messages\"2\n\x0fPub\
    lishResponse\x12\x1f\n\x0bmessage_ids\x18\x01\x20\x03(\tR\nmessageIds\"i\
    \n\x11ListTopicsRequest\x12\x18\n\x07project\x18\x01\x20\x01(\tR\x07proj\
    ect\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\n\npa\
    ge_token\x18\x03\x20\x01(\tR\tpageToken\"r\n\x12ListTopicsResponse\x124\
    \n\x06topics\x18\x01\x20\x03(\x0b2\x1c.google.pubsub.v1beta2.TopicR\x06t\
    opics\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"q\n\
    \x1dListTopicSubscriptionsRequest\x12\x14\n\x05topic\x18\x01\x20\x01(\tR\
    \x05topic\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\
    \n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"n\n\x1eListTopicSubscript\
    ionsResponse\x12$\n\rsubscriptions\x18\x01\x20\x03(\tR\rsubscriptions\
    \x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"*\n\x12De\
    leteTopicRequest\x12\x14\n\x05topic\x18\x01\x20\x01(\tR\x05topic\"\xae\
    \x01\n\x0cSubscription\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\
    \x14\n\x05topic\x18\x02\x20\x01(\tR\x05topic\x12B\n\x0bpush_config\x18\
    \x04\x20\x01(\x0b2!.google.pubsub.v1beta2.PushConfigR\npushConfig\x120\n\
    \x14ack_deadline_seconds\x18\x05\x20\x01(\x05R\x12ackDeadlineSeconds\"\
    \xc3\x01\n\nPushConfig\x12#\n\rpush_endpoint\x18\x01\x20\x01(\tR\x0cpush\
    Endpoint\x12Q\n\nattributes\x18\x02\x20\x03(\x0b21.google.pubsub.v1beta2\
    .PushConfig.AttributesEntryR\nattributes\x1a=\n\x0fAttributesEntry\x12\
    \x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\
    \x01(\tR\x05value:\x028\x01\"h\n\x0fReceivedMessage\x12\x15\n\x06ack_id\
    \x18\x01\x20\x01(\tR\x05ackId\x12>\n\x07message\x18\x02\x20\x01(\x0b2$.g\
    oogle.pubsub.v1beta2.PubsubMessageR\x07message\"<\n\x16GetSubscriptionRe\
    quest\x12\"\n\x0csubscription\x18\x01\x20\x01(\tR\x0csubscription\"p\n\
    \x18ListSubscriptionsRequest\x12\x18\n\x07project\x18\x01\x20\x01(\tR\
    \x07project\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\
    \x1d\n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"\x8e\x01\n\x19ListSub\
    scriptionsResponse\x12I\n\rsubscriptions\x18\x01\x20\x03(\x0b2#.google.p\
    ubsub.v1beta2.SubscriptionR\rsubscriptions\x12&\n\x0fnext_page_token\x18\
    \x02\x20\x01(\tR\rnextPageToken\"?\n\x19DeleteSubscriptionRequest\x12\"\
    \n\x0csubscription\x18\x01\x20\x01(\tR\x0csubscription\"\x81\x01\n\x17Mo\
    difyPushConfigRequest\x12\"\n\x0csubscription\x18\x01\x20\x01(\tR\x0csub\
    scription\x12B\n\x0bpush_config\x18\x02\x20\x01(\x0b2!.google.pubsub.v1b\
    eta2.PushConfigR\npushConfig\"\x83\x01\n\x0bPullRequest\x12\"\n\x0csubsc\
    ription\x18\x01\x20\x01(\tR\x0csubscription\x12-\n\x12return_immediately\
    \x18\x02\x20\x01(\x08R\x11returnImmediately\x12!\n\x0cmax_messages\x18\
    \x03\x20\x01(\x05R\x0bmaxMessages\"c\n\x0cPullResponse\x12S\n\x11receive\
    d_messages\x18\x01\x20\x03(\x0b2&.google.pubsub.v1beta2.ReceivedMessageR\
    \x10receivedMessages\"\x87\x01\n\x18ModifyAckDeadlineRequest\x12\"\n\x0c\
    subscription\x18\x01\x20\x01(\tR\x0csubscription\x12\x15\n\x06ack_id\x18\
    \x02\x20\x01(\tR\x05ackId\x120\n\x14ack_deadline_seconds\x18\x03\x20\x01\
    (\x05R\x12ackDeadlineSeconds\"Q\n\x12AcknowledgeRequest\x12\"\n\x0csubsc\
    ription\x18\x01\x20\x01(\tR\x0csubscription\x12\x17\n\x07ack_ids\x18\x02\
    \x20\x03(\tR\x06ackIds2\x88\x06\n\nSubscriber\x12^\n\x12CreateSubscripti\
    on\x12#.google.pubsub.v1beta2.Subscription\x1a#.google.pubsub.v1beta2.Su\
    bscription\x12e\n\x0fGetSubscription\x12-.google.pubsub.v1beta2.GetSubsc\
    riptionRequest\x1a#.google.pubsub.v1beta2.Subscription\x12v\n\x11ListSub\
    scriptions\x12/.google.pubsub.v1beta2.ListSubscriptionsRequest\x1a0.goog\
    le.pubsub.v1beta2.ListSubscriptionsResponse\x12^\n\x12DeleteSubscription\
    \x120.google.pubsub.v1beta2.DeleteSubscriptionRequest\x1a\x16.google.pro\
    tobuf.Empty\x12\\\n\x11ModifyAckDeadline\x12/.google.pubsub.v1beta2.Modi\
    fyAckDeadlineRequest\x1a\x16.google.protobuf.Empty\x12P\n\x0bAcknowledge\
    \x12).google.pubsub.v1beta2.AcknowledgeRequest\x1a\x16.google.protobuf.E\
    mpty\x12O\n\x04Pull\x12\".google.pubsub.v1beta2.PullRequest\x1a#.google.\
    pubsub.v1beta2.PullResponse\x12Z\n\x10ModifyPushConfig\x12..google.pubsu\
    b.v1beta2.ModifyPushConfigRequest\x1a\x16.google.protobuf.Empty2\xbf\x04\
    \n\tPublisher\x12I\n\x0bCreateTopic\x12\x1c.google.pubsub.v1beta2.Topic\
    \x1a\x1c.google.pubsub.v1beta2.Topic\x12X\n\x07Publish\x12%.google.pubsu\
    b.v1beta2.PublishRequest\x1a&.google.pubsub.v1beta2.PublishResponse\x12P\
    \n\x08GetTopic\x12&.google.pubsub.v1beta2.GetTopicRequest\x1a\x1c.google\
    .pubsub.v1beta2.Topic\x12a\n\nListTopics\x12(.google.pubsub.v1beta2.List\
    TopicsRequest\x1a).google.pubsub.v1beta2.ListTopicsResponse\x12\x85\x01\
    \n\x16ListTopicSubscriptions\x124.google.pubsub.v1beta2.ListTopicSubscri\
    ptionsRequest\x1a5.google.pubsub.v1beta2.ListTopicSubscriptionsResponse\
    \x12P\n\x0bDeleteTopic\x12).google.pubsub.v1beta2.DeleteTopicRequest\x1a\
    \x16.google.protobuf.EmptyBg\n\x19com.google.pubsub.v1beta2B\x0bPubsubPr\
    otoP\x01Z;google.golang.org/genproto/googleapis/pubsub/v1beta2;pubsubJ\
    \xeds\n\x07\x12\x05\x0e\0\x82\x03\x01\n\xc2\x04\n\x01\x0c\x12\x03\x0e\0\
    \x122\xb7\x04\x20Copyright\x20(c)\x202015,\x20Google\x20Inc.\n\n\x20Lice\
    nsed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\x20\
    \"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20except\
    \x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20obtai\
    n\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http\
    ://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\x08\n\x01\x02\x12\x03\x10\0\x1e\n\t\n\x02\x03\0\x12\x03\x12\0%\n\
    \x08\n\x01\x08\x12\x03\x14\0R\n\t\n\x02\x08\x0b\x12\x03\x14\0R\n\x08\n\
    \x01\x08\x12\x03\x15\0\"\n\t\n\x02\x08\n\x12\x03\x15\0\"\n\x08\n\x01\x08\
    \x12\x03\x16\0,\n\t\n\x02\x08\x08\x12\x03\x16\0,\n\x08\n\x01\x08\x12\x03\
    \x17\02\n\t\n\x02\x08\x01\x12\x03\x17\02\n\x91\x01\n\x02\x06\0\x12\x04\
    \x1b\0Q\x01\x1a\x84\x01\x20The\x20service\x20that\x20an\x20application\
    \x20uses\x20to\x20manipulate\x20subscriptions\x20and\x20to\n\x20consume\
    \x20messages\x20from\x20a\x20subscription\x20via\x20the\x20Pull\x20metho\
    d.\n\n\n\n\x03\x06\0\x01\x12\x03\x1b\x08\x12\n\xd6\x02\n\x04\x06\0\x02\0\
    \x12\x03\"\x02>\x1a\xc8\x02\x20Creates\x20a\x20subscription\x20to\x20a\
    \x20given\x20topic\x20for\x20a\x20given\x20subscriber.\n\x20If\x20the\
    \x20subscription\x20already\x20exists,\x20returns\x20ALREADY_EXISTS.\n\
    \x20If\x20the\x20corresponding\x20topic\x20doesn't\x20exist,\x20returns\
    \x20NOT_FOUND.\n\n\x20If\x20the\x20name\x20is\x20not\x20provided\x20in\
    \x20the\x20request,\x20the\x20server\x20will\x20assign\x20a\x20random\n\
    \x20name\x20for\x20this\x20subscription\x20on\x20the\x20same\x20project\
    \x20as\x20the\x20topic.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03\"\x06\x18\
    \n\x0c\n\x05\x06\0\x02\0\x02\x12\x03\"\x19%\n\x0c\n\x05\x06\0\x02\0\x03\
    \x12\x03\"0<\n@\n\x04\x06\0\x02\x01\x12\x03%\x02E\x1a3\x20Gets\x20the\
    \x20configuration\x20details\x20of\x20a\x20subscription.\n\n\x0c\n\x05\
    \x06\0\x02\x01\x01\x12\x03%\x06\x15\n\x0c\n\x05\x06\0\x02\x01\x02\x12\
    \x03%\x16,\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03%7C\n-\n\x04\x06\0\x02\
    \x02\x12\x04(\x02)*\x1a\x1f\x20Lists\x20matching\x20subscriptions.\n\n\
    \x0c\n\x05\x06\0\x02\x02\x01\x12\x03(\x06\x17\n\x0c\n\x05\x06\0\x02\x02\
    \x02\x12\x03(\x180\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03)\x0f(\n\xe9\x02\
    \n\x04\x06\0\x02\x03\x12\x040\x021&\x1a\xda\x02\x20Deletes\x20an\x20exis\
    ting\x20subscription.\x20All\x20pending\x20messages\x20in\x20the\x20subs\
    cription\n\x20are\x20immediately\x20dropped.\x20Calls\x20to\x20Pull\x20a\
    fter\x20deletion\x20will\x20return\n\x20NOT_FOUND.\x20After\x20a\x20subs\
    cription\x20is\x20deleted,\x20a\x20new\x20one\x20may\x20be\x20created\
    \x20with\n\x20the\x20same\x20name,\x20but\x20the\x20new\x20one\x20has\
    \x20no\x20association\x20with\x20the\x20old\n\x20subscription,\x20or\x20\
    its\x20topic\x20unless\x20the\x20same\x20topic\x20is\x20specified.\n\n\
    \x0c\n\x05\x06\0\x02\x03\x01\x12\x030\x06\x18\n\x0c\n\x05\x06\0\x02\x03\
    \x02\x12\x030\x192\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x031\x0f$\n\xfb\x01\
    \n\x04\x06\0\x02\x04\x12\x047\x028&\x1a\xec\x01\x20Modifies\x20the\x20ac\
    k\x20deadline\x20for\x20a\x20specific\x20message.\x20This\x20method\x20i\
    s\x20useful\x20to\n\x20indicate\x20that\x20more\x20time\x20is\x20needed\
    \x20to\x20process\x20a\x20message\x20by\x20the\x20subscriber,\n\x20or\
    \x20to\x20make\x20the\x20message\x20available\x20for\x20redelivery\x20if\
    \x20the\x20processing\x20was\n\x20interrupted.\n\n\x0c\n\x05\x06\0\x02\
    \x04\x01\x12\x037\x06\x17\n\x0c\n\x05\x06\0\x02\x04\x02\x12\x037\x180\n\
    \x0c\n\x05\x06\0\x02\x04\x03\x12\x038\x0f$\n\xe9\x02\n\x04\x06\0\x02\x05\
    \x12\x03A\x02F\x1a\xdb\x02\x20Acknowledges\x20the\x20messages\x20associa\
    ted\x20with\x20the\x20ack\x20tokens\x20in\x20the\n\x20AcknowledgeRequest\
    .\x20The\x20Pub/Sub\x20system\x20can\x20remove\x20the\x20relevant\x20mes\
    sages\n\x20from\x20the\x20subscription.\n\n\x20Acknowledging\x20a\x20mes\
    sage\x20whose\x20ack\x20deadline\x20has\x20expired\x20may\x20succeed,\n\
    \x20but\x20such\x20a\x20message\x20may\x20be\x20redelivered\x20later.\
    \x20Acknowledging\x20a\x20message\x20more\n\x20than\x20once\x20will\x20n\
    ot\x20result\x20in\x20an\x20error.\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\
    \x03A\x06\x11\n\x0c\n\x05\x06\0\x02\x05\x02\x12\x03A\x12$\n\x0c\n\x05\
    \x06\0\x02\x05\x03\x12\x03A/D\n\xf0\x01\n\x04\x06\0\x02\x06\x12\x03G\x02\
    /\x1a\xe2\x01\x20Pulls\x20messages\x20from\x20the\x20server.\x20Returns\
    \x20an\x20empty\x20list\x20if\x20there\x20are\x20no\n\x20messages\x20ava\
    ilable\x20in\x20the\x20backlog.\x20The\x20server\x20may\x20return\x20UNA\
    VAILABLE\x20if\n\x20there\x20are\x20too\x20many\x20concurrent\x20pull\
    \x20requests\x20pending\x20for\x20the\x20given\n\x20subscription.\n\n\
    \x0c\n\x05\x06\0\x02\x06\x01\x12\x03G\x06\n\n\x0c\n\x05\x06\0\x02\x06\
    \x02\x12\x03G\x0b\x16\n\x0c\n\x05\x06\0\x02\x06\x03\x12\x03G!-\n\xef\x02\
    \n\x04\x06\0\x02\x07\x12\x03P\x02P\x1a\xe1\x02\x20Modifies\x20the\x20Pus\
    hConfig\x20for\x20a\x20specified\x20subscription.\n\n\x20This\x20may\x20\
    be\x20used\x20to\x20change\x20a\x20push\x20subscription\x20to\x20a\x20pu\
    ll\x20one\x20(signified\n\x20by\x20an\x20empty\x20PushConfig)\x20or\x20v\
    ice\x20versa,\x20or\x20change\x20the\x20endpoint\x20URL\x20and\x20other\
    \n\x20attributes\x20of\x20a\x20push\x20subscription.\x20Messages\x20will\
    \x20accumulate\x20for\n\x20delivery\x20continuously\x20through\x20the\
    \x20call\x20regardless\x20of\x20changes\x20to\x20the\n\x20PushConfig.\n\
    \n\x0c\n\x05\x06\0\x02\x07\x01\x12\x03P\x06\x16\n\x0c\n\x05\x06\0\x02\
    \x07\x02\x12\x03P\x17.\n\x0c\n\x05\x06\0\x02\x07\x03\x12\x03P9N\nj\n\x02\
    \x06\x01\x12\x04U\0m\x01\x1a^\x20The\x20service\x20that\x20an\x20applica\
    tion\x20uses\x20to\x20manipulate\x20topics,\x20and\x20to\x20send\n\x20me\
    ssages\x20to\x20a\x20topic.\n\n\n\n\x03\x06\x01\x01\x12\x03U\x08\x11\n;\
    \n\x04\x06\x01\x02\0\x12\x03W\x02)\x1a.\x20Creates\x20the\x20given\x20to\
    pic\x20with\x20the\x20given\x20name.\n\n\x0c\n\x05\x06\x01\x02\0\x01\x12\
    \x03W\x06\x11\n\x0c\n\x05\x06\x01\x02\0\x02\x12\x03W\x12\x17\n\x0c\n\x05\
    \x06\x01\x02\0\x03\x12\x03W\"'\nf\n\x04\x06\x01\x02\x01\x12\x03[\x028\
    \x1aY\x20Adds\x20one\x20or\x20more\x20messages\x20to\x20the\x20topic.\
    \x20Returns\x20NOT_FOUND\x20if\x20the\x20topic\x20does\n\x20not\x20exist\
    .\n\n\x0c\n\x05\x06\x01\x02\x01\x01\x12\x03[\x06\r\n\x0c\n\x05\x06\x01\
    \x02\x01\x02\x12\x03[\x0e\x1c\n\x0c\n\x05\x06\x01\x02\x01\x03\x12\x03['6\
    \n1\n\x04\x06\x01\x02\x02\x12\x03^\x020\x1a$\x20Gets\x20the\x20configura\
    tion\x20of\x20a\x20topic.\n\n\x0c\n\x05\x06\x01\x02\x02\x01\x12\x03^\x06\
    \x0e\n\x0c\n\x05\x06\x01\x02\x02\x02\x12\x03^\x0f\x1e\n\x0c\n\x05\x06\
    \x01\x02\x02\x03\x12\x03^).\n%\n\x04\x06\x01\x02\x03\x12\x03a\x02A\x1a\
    \x18\x20Lists\x20matching\x20topics.\n\n\x0c\n\x05\x06\x01\x02\x03\x01\
    \x12\x03a\x06\x10\n\x0c\n\x05\x06\x01\x02\x03\x02\x12\x03a\x11\"\n\x0c\n\
    \x05\x06\x01\x02\x03\x03\x12\x03a-?\nC\n\x04\x06\x01\x02\x04\x12\x04d\
    \x02e/\x1a5\x20Lists\x20the\x20name\x20of\x20the\x20subscriptions\x20for\
    \x20this\x20topic.\n\n\x0c\n\x05\x06\x01\x02\x04\x01\x12\x03d\x06\x1c\n\
    \x0c\n\x05\x06\x01\x02\x04\x02\x12\x03d\x1d:\n\x0c\n\x05\x06\x01\x02\x04\
    \x03\x12\x03e\x0f-\n\xbb\x02\n\x04\x06\x01\x02\x05\x12\x03l\x02F\x1a\xad\
    \x02\x20Deletes\x20the\x20topic\x20with\x20the\x20given\x20name.\x20Retu\
    rns\x20NOT_FOUND\x20if\x20the\x20topic\x20does\n\x20not\x20exist.\x20Aft\
    er\x20a\x20topic\x20is\x20deleted,\x20a\x20new\x20topic\x20may\x20be\x20\
    created\x20with\x20the\n\x20same\x20name;\x20this\x20is\x20an\x20entirel\
    y\x20new\x20topic\x20with\x20none\x20of\x20the\x20old\n\x20configuration\
    \x20or\x20subscriptions.\x20Existing\x20subscriptions\x20to\x20this\x20t\
    opic\x20are\n\x20not\x20deleted.\n\n\x0c\n\x05\x06\x01\x02\x05\x01\x12\
    \x03l\x06\x11\n\x0c\n\x05\x06\x01\x02\x05\x02\x12\x03l\x12$\n\x0c\n\x05\
    \x06\x01\x02\x05\x03\x12\x03l/D\n\x1f\n\x02\x04\0\x12\x04p\0s\x01\x1a\
    \x13\x20A\x20topic\x20resource.\n\n\n\n\x03\x04\0\x01\x12\x03p\x08\r\n!\
    \n\x04\x04\0\x02\0\x12\x03r\x02\x12\x1a\x14\x20Name\x20of\x20the\x20topi\
    c.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03r\x02\x08\n\x0c\n\x05\x04\0\x02\
    \0\x01\x12\x03r\t\r\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03r\x10\x11\n1\n\
    \x02\x04\x01\x12\x05v\0\x83\x01\x01\x1a$\x20A\x20message\x20data\x20and\
    \x20its\x20attributes.\n\n\n\n\x03\x04\x01\x01\x12\x03v\x08\x15\ng\n\x04\
    \x04\x01\x02\0\x12\x03y\x02\x11\x1aZ\x20The\x20message\x20payload.\x20Fo\
    r\x20JSON\x20requests,\x20the\x20value\x20of\x20this\x20field\x20must\
    \x20be\n\x20base64-encoded.\n\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03y\x02\
    \x07\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03y\x08\x0c\n\x0c\n\x05\x04\x01\
    \x02\0\x03\x12\x03y\x0f\x10\n4\n\x04\x04\x01\x02\x01\x12\x03|\x02%\x1a'\
    \x20Optional\x20attributes\x20for\x20this\x20message.\n\n\x0c\n\x05\x04\
    \x01\x02\x01\x06\x12\x03|\x02\x15\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\
    \x03|\x16\x20\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03|#$\n\xa0\x02\n\x04\
    \x04\x01\x02\x02\x12\x04\x82\x01\x02\x18\x1a\x91\x02\x20ID\x20of\x20this\
    \x20message\x20assigned\x20by\x20the\x20server\x20at\x20publication\x20t\
    ime.\x20Guaranteed\n\x20to\x20be\x20unique\x20within\x20the\x20topic.\
    \x20This\x20value\x20may\x20be\x20read\x20by\x20a\x20subscriber\n\x20tha\
    t\x20receives\x20a\x20PubsubMessage\x20via\x20a\x20Pull\x20call\x20or\
    \x20a\x20push\x20delivery.\x20It\x20must\n\x20not\x20be\x20populated\x20\
    by\x20a\x20publisher\x20in\x20a\x20Publish\x20call.\n\n\r\n\x05\x04\x01\
    \x02\x02\x05\x12\x04\x82\x01\x02\x08\n\r\n\x05\x04\x01\x02\x02\x01\x12\
    \x04\x82\x01\t\x13\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\x82\x01\x16\x17\
    \n0\n\x02\x04\x02\x12\x06\x86\x01\0\x89\x01\x01\x1a\"\x20Request\x20for\
    \x20the\x20GetTopic\x20method.\n\n\x0b\n\x03\x04\x02\x01\x12\x04\x86\x01\
    \x08\x17\n-\n\x04\x04\x02\x02\0\x12\x04\x88\x01\x02\x13\x1a\x1f\x20The\
    \x20name\x20of\x20the\x20topic\x20to\x20get.\n\n\r\n\x05\x04\x02\x02\0\
    \x05\x12\x04\x88\x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\x88\x01\
    \t\x0e\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\x88\x01\x11\x12\n/\n\x02\x04\
    \x03\x12\x06\x8c\x01\0\x92\x01\x01\x1a!\x20Request\x20for\x20the\x20Publ\
    ish\x20method.\n\n\x0b\n\x03\x04\x03\x01\x12\x04\x8c\x01\x08\x16\nL\n\
    \x04\x04\x03\x02\0\x12\x04\x8e\x01\x02\x13\x1a>\x20The\x20messages\x20in\
    \x20the\x20request\x20will\x20be\x20published\x20on\x20this\x20topic.\n\
    \n\r\n\x05\x04\x03\x02\0\x05\x12\x04\x8e\x01\x02\x08\n\r\n\x05\x04\x03\
    \x02\0\x01\x12\x04\x8e\x01\t\x0e\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\x8e\
    \x01\x11\x12\n(\n\x04\x04\x03\x02\x01\x12\x04\x91\x01\x02&\x1a\x1a\x20Th\
    e\x20messages\x20to\x20publish.\n\n\r\n\x05\x04\x03\x02\x01\x04\x12\x04\
    \x91\x01\x02\n\n\r\n\x05\x04\x03\x02\x01\x06\x12\x04\x91\x01\x0b\x18\n\r\
    \n\x05\x04\x03\x02\x01\x01\x12\x04\x91\x01\x19!\n\r\n\x05\x04\x03\x02\
    \x01\x03\x12\x04\x91\x01$%\n0\n\x02\x04\x04\x12\x06\x95\x01\0\x9a\x01\
    \x01\x1a\"\x20Response\x20for\x20the\x20Publish\x20method.\n\n\x0b\n\x03\
    \x04\x04\x01\x12\x04\x95\x01\x08\x17\n\xa8\x01\n\x04\x04\x04\x02\0\x12\
    \x04\x99\x01\x02\"\x1a\x99\x01\x20The\x20server-assigned\x20ID\x20of\x20\
    each\x20published\x20message,\x20in\x20the\x20same\x20order\x20as\n\x20t\
    he\x20messages\x20in\x20the\x20request.\x20IDs\x20are\x20guaranteed\x20t\
    o\x20be\x20unique\x20within\n\x20the\x20topic.\n\n\r\n\x05\x04\x04\x02\0\
    \x04\x12\x04\x99\x01\x02\n\n\r\n\x05\x04\x04\x02\0\x05\x12\x04\x99\x01\
    \x0b\x11\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\x99\x01\x12\x1d\n\r\n\x05\
    \x04\x04\x02\0\x03\x12\x04\x99\x01\x20!\n2\n\x02\x04\x05\x12\x06\x9d\x01\
    \0\xa8\x01\x01\x1a$\x20Request\x20for\x20the\x20ListTopics\x20method.\n\
    \n\x0b\n\x03\x04\x05\x01\x12\x04\x9d\x01\x08\x19\nD\n\x04\x04\x05\x02\0\
    \x12\x04\x9f\x01\x02\x15\x1a6\x20The\x20name\x20of\x20the\x20cloud\x20pr\
    oject\x20that\x20topics\x20belong\x20to.\n\n\r\n\x05\x04\x05\x02\0\x05\
    \x12\x04\x9f\x01\x02\x08\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\x9f\x01\t\
    \x10\n\r\n\x05\x04\x05\x02\0\x03\x12\x04\x9f\x01\x13\x14\n3\n\x04\x04\
    \x05\x02\x01\x12\x04\xa2\x01\x02\x16\x1a%\x20Maximum\x20number\x20of\x20\
    topics\x20to\x20return.\n\n\r\n\x05\x04\x05\x02\x01\x05\x12\x04\xa2\x01\
    \x02\x07\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\xa2\x01\x08\x11\n\r\n\x05\
    \x04\x05\x02\x01\x03\x12\x04\xa2\x01\x14\x15\n\xc0\x01\n\x04\x04\x05\x02\
    \x02\x12\x04\xa7\x01\x02\x18\x1a\xb1\x01\x20The\x20value\x20returned\x20\
    by\x20the\x20last\x20ListTopicsResponse;\x20indicates\x20that\x20this\
    \x20is\n\x20a\x20continuation\x20of\x20a\x20prior\x20ListTopics\x20call,\
    \x20and\x20that\x20the\x20system\x20should\n\x20return\x20the\x20next\
    \x20page\x20of\x20data.\n\n\r\n\x05\x04\x05\x02\x02\x05\x12\x04\xa7\x01\
    \x02\x08\n\r\n\x05\x04\x05\x02\x02\x01\x12\x04\xa7\x01\t\x13\n\r\n\x05\
    \x04\x05\x02\x02\x03\x12\x04\xa7\x01\x16\x17\n3\n\x02\x04\x06\x12\x06\
    \xab\x01\0\xb2\x01\x01\x1a%\x20Response\x20for\x20the\x20ListTopics\x20m\
    ethod.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\xab\x01\x08\x1a\n%\n\x04\x04\
    \x06\x02\0\x12\x04\xad\x01\x02\x1c\x1a\x17\x20The\x20resulting\x20topics\
    .\n\n\r\n\x05\x04\x06\x02\0\x04\x12\x04\xad\x01\x02\n\n\r\n\x05\x04\x06\
    \x02\0\x06\x12\x04\xad\x01\x0b\x10\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\
    \xad\x01\x11\x17\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xad\x01\x1a\x1b\n\
    \x97\x01\n\x04\x04\x06\x02\x01\x12\x04\xb1\x01\x02\x1d\x1a\x88\x01\x20If\
    \x20not\x20empty,\x20indicates\x20that\x20there\x20may\x20be\x20more\x20\
    topics\x20that\x20match\x20the\n\x20request;\x20this\x20value\x20should\
    \x20be\x20passed\x20in\x20a\x20new\x20ListTopicsRequest.\n\n\r\n\x05\x04\
    \x06\x02\x01\x05\x12\x04\xb1\x01\x02\x08\n\r\n\x05\x04\x06\x02\x01\x01\
    \x12\x04\xb1\x01\t\x18\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\xb1\x01\x1b\
    \x1c\n>\n\x02\x04\x07\x12\x06\xb5\x01\0\xc0\x01\x01\x1a0\x20Request\x20f\
    or\x20the\x20ListTopicSubscriptions\x20method.\n\n\x0b\n\x03\x04\x07\x01\
    \x12\x04\xb5\x01\x08%\nI\n\x04\x04\x07\x02\0\x12\x04\xb7\x01\x02\x13\x1a\
    ;\x20The\x20name\x20of\x20the\x20topic\x20that\x20subscriptions\x20are\
    \x20attached\x20to.\n\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\xb7\x01\x02\
    \x08\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xb7\x01\t\x0e\n\r\n\x05\x04\x07\
    \x02\0\x03\x12\x04\xb7\x01\x11\x12\n?\n\x04\x04\x07\x02\x01\x12\x04\xba\
    \x01\x02\x16\x1a1\x20Maximum\x20number\x20of\x20subscription\x20names\
    \x20to\x20return.\n\n\r\n\x05\x04\x07\x02\x01\x05\x12\x04\xba\x01\x02\
    \x07\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\xba\x01\x08\x11\n\r\n\x05\x04\
    \x07\x02\x01\x03\x12\x04\xba\x01\x14\x15\n\xd8\x01\n\x04\x04\x07\x02\x02\
    \x12\x04\xbf\x01\x02\x18\x1a\xc9\x01\x20The\x20value\x20returned\x20by\
    \x20the\x20last\x20ListTopicSubscriptionsResponse;\x20indicates\n\x20tha\
    t\x20this\x20is\x20a\x20continuation\x20of\x20a\x20prior\x20ListTopicSub\
    scriptions\x20call,\x20and\n\x20that\x20the\x20system\x20should\x20retur\
    n\x20the\x20next\x20page\x20of\x20data.\n\n\r\n\x05\x04\x07\x02\x02\x05\
    \x12\x04\xbf\x01\x02\x08\n\r\n\x05\x04\x07\x02\x02\x01\x12\x04\xbf\x01\t\
    \x13\n\r\n\x05\x04\x07\x02\x02\x03\x12\x04\xbf\x01\x16\x17\n?\n\x02\x04\
    \x08\x12\x06\xc3\x01\0\xcb\x01\x01\x1a1\x20Response\x20for\x20the\x20Lis\
    tTopicSubscriptions\x20method.\n\n\x0b\n\x03\x04\x08\x01\x12\x04\xc3\x01\
    \x08&\nF\n\x04\x04\x08\x02\0\x12\x04\xc5\x01\x02$\x1a8\x20The\x20names\
    \x20of\x20the\x20subscriptions\x20that\x20match\x20the\x20request.\n\n\r\
    \n\x05\x04\x08\x02\0\x04\x12\x04\xc5\x01\x02\n\n\r\n\x05\x04\x08\x02\0\
    \x05\x12\x04\xc5\x01\x0b\x11\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\xc5\x01\
    \x12\x1f\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xc5\x01\"#\n\xc5\x01\n\x04\
    \x04\x08\x02\x01\x12\x04\xca\x01\x02\x1d\x1a\xb6\x01\x20If\x20not\x20emp\
    ty,\x20indicates\x20that\x20there\x20may\x20be\x20more\x20subscriptions\
    \x20that\x20match\n\x20the\x20request;\x20this\x20value\x20should\x20be\
    \x20passed\x20in\x20a\x20new\n\x20ListTopicSubscriptionsRequest\x20to\
    \x20get\x20more\x20subscriptions.\n\n\r\n\x05\x04\x08\x02\x01\x05\x12\
    \x04\xca\x01\x02\x08\n\r\n\x05\x04\x08\x02\x01\x01\x12\x04\xca\x01\t\x18\
    \n\r\n\x05\x04\x08\x02\x01\x03\x12\x04\xca\x01\x1b\x1c\n3\n\x02\x04\t\
    \x12\x06\xce\x01\0\xd1\x01\x01\x1a%\x20Request\x20for\x20the\x20DeleteTo\
    pic\x20method.\n\n\x0b\n\x03\x04\t\x01\x12\x04\xce\x01\x08\x1a\n,\n\x04\
    \x04\t\x02\0\x12\x04\xd0\x01\x02\x13\x1a\x1e\x20Name\x20of\x20the\x20top\
    ic\x20to\x20delete.\n\n\r\n\x05\x04\t\x02\0\x05\x12\x04\xd0\x01\x02\x08\
    \n\r\n\x05\x04\t\x02\0\x01\x12\x04\xd0\x01\t\x0e\n\r\n\x05\x04\t\x02\0\
    \x03\x12\x04\xd0\x01\x11\x12\n(\n\x02\x04\n\x12\x06\xd4\x01\0\xf2\x01\
    \x01\x1a\x1a\x20A\x20subscription\x20resource.\n\n\x0b\n\x03\x04\n\x01\
    \x12\x04\xd4\x01\x08\x14\n)\n\x04\x04\n\x02\0\x12\x04\xd6\x01\x02\x12\
    \x1a\x1b\x20Name\x20of\x20the\x20subscription.\n\n\r\n\x05\x04\n\x02\0\
    \x05\x12\x04\xd6\x01\x02\x08\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xd6\x01\t\
    \r\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xd6\x01\x10\x11\n\xb7\x01\n\x04\x04\
    \n\x02\x01\x12\x04\xdb\x01\x02\x13\x1a\xa8\x01\x20The\x20name\x20of\x20t\
    he\x20topic\x20from\x20which\x20this\x20subscription\x20is\x20receiving\
    \x20messages.\n\x20This\x20will\x20be\x20present\x20if\x20and\x20only\
    \x20if\x20the\x20subscription\x20has\x20not\x20been\x20detached\n\x20fro\
    m\x20its\x20topic.\n\n\r\n\x05\x04\n\x02\x01\x05\x12\x04\xdb\x01\x02\x08\
    \n\r\n\x05\x04\n\x02\x01\x01\x12\x04\xdb\x01\t\x0e\n\r\n\x05\x04\n\x02\
    \x01\x03\x12\x04\xdb\x01\x11\x12\n\xc7\x01\n\x04\x04\n\x02\x02\x12\x04\
    \xe0\x01\x02\x1d\x1a\xb8\x01\x20If\x20push\x20delivery\x20is\x20used\x20\
    with\x20this\x20subscription,\x20this\x20field\x20is\n\x20used\x20to\x20\
    configure\x20it.\x20An\x20empty\x20pushConfig\x20signifies\x20that\x20th\
    e\x20subscriber\n\x20will\x20pull\x20and\x20ack\x20messages\x20using\x20\
    API\x20methods.\n\n\r\n\x05\x04\n\x02\x02\x06\x12\x04\xe0\x01\x02\x0c\n\
    \r\n\x05\x04\n\x02\x02\x01\x12\x04\xe0\x01\r\x18\n\r\n\x05\x04\n\x02\x02\
    \x03\x12\x04\xe0\x01\x1b\x1c\n\xd3\x05\n\x04\x04\n\x02\x03\x12\x04\xf1\
    \x01\x02!\x1a\xc4\x05\x20This\x20value\x20is\x20the\x20maximum\x20time\
    \x20after\x20a\x20subscriber\x20receives\x20a\x20message\n\x20before\x20\
    the\x20subscriber\x20should\x20acknowledge\x20the\x20message.\x20After\
    \x20message\n\x20delivery\x20but\x20before\x20the\x20ack\x20deadline\x20\
    expires\x20and\x20before\x20the\x20message\x20is\n\x20acknowledged,\x20i\
    t\x20is\x20an\x20outstanding\x20message\x20and\x20will\x20not\x20be\x20d\
    elivered\n\x20again\x20during\x20that\x20time\x20(on\x20a\x20best-effort\
    \x20basis).\n\n\x20For\x20pull\x20delivery\x20this\x20value\n\x20is\x20u\
    sed\x20as\x20the\x20initial\x20value\x20for\x20the\x20ack\x20deadline.\
    \x20It\x20may\x20be\x20overridden\n\x20for\x20a\x20specific\x20message\
    \x20by\x20calling\x20ModifyAckDeadline.\n\n\x20For\x20push\x20delivery,\
    \x20this\x20value\x20is\x20also\x20used\x20to\x20set\x20the\x20request\
    \x20timeout\x20for\n\x20the\x20call\x20to\x20the\x20push\x20endpoint.\n\
    \n\x20If\x20the\x20subscriber\x20never\x20acknowledges\x20the\x20message\
    ,\x20the\x20Pub/Sub\n\x20system\x20will\x20eventually\x20redeliver\x20th\
    e\x20message.\n\n\r\n\x05\x04\n\x02\x03\x05\x12\x04\xf1\x01\x02\x07\n\r\
    \n\x05\x04\n\x02\x03\x01\x12\x04\xf1\x01\x08\x1c\n\r\n\x05\x04\n\x02\x03\
    \x03\x12\x04\xf1\x01\x1f\x20\n;\n\x02\x04\x0b\x12\x06\xf5\x01\0\x92\x02\
    \x01\x1a-\x20Configuration\x20for\x20a\x20push\x20delivery\x20endpoint.\
    \n\n\x0b\n\x03\x04\x0b\x01\x12\x04\xf5\x01\x08\x12\n\x97\x01\n\x04\x04\
    \x0b\x02\0\x12\x04\xf8\x01\x02\x1b\x1a\x88\x01\x20A\x20URL\x20locating\
    \x20the\x20endpoint\x20to\x20which\x20messages\x20should\x20be\x20pushed\
    .\n\x20For\x20example,\x20a\x20Webhook\x20endpoint\x20might\x20use\x20\"\
    https://example.com/push\".\n\n\r\n\x05\x04\x0b\x02\0\x05\x12\x04\xf8\
    \x01\x02\x08\n\r\n\x05\x04\x0b\x02\0\x01\x12\x04\xf8\x01\t\x16\n\r\n\x05\
    \x04\x0b\x02\0\x03\x12\x04\xf8\x01\x19\x1a\n\xfe\x07\n\x04\x04\x0b\x02\
    \x01\x12\x04\x91\x02\x02%\x1a\xef\x07\x20Endpoint\x20configuration\x20at\
    tributes.\n\n\x20Every\x20endpoint\x20has\x20a\x20set\x20of\x20API\x20su\
    pported\x20attributes\x20that\x20can\x20be\x20used\x20to\n\x20control\
    \x20different\x20aspects\x20of\x20the\x20message\x20delivery.\n\n\x20The\
    \x20currently\x20supported\x20attribute\x20is\x20`x-goog-version`,\x20wh\
    ich\x20you\x20can\n\x20use\x20to\x20change\x20the\x20format\x20of\x20the\
    \x20push\x20message.\x20This\x20attribute\n\x20indicates\x20the\x20versi\
    on\x20of\x20the\x20data\x20expected\x20by\x20the\x20endpoint.\x20This\n\
    \x20controls\x20the\x20shape\x20of\x20the\x20envelope\x20(i.e.\x20its\
    \x20fields\x20and\x20metadata).\n\x20The\x20endpoint\x20version\x20is\
    \x20based\x20on\x20the\x20version\x20of\x20the\x20Pub/Sub\n\x20API.\n\n\
    \x20If\x20not\x20present\x20during\x20the\x20CreateSubscription\x20call,\
    \x20it\x20will\x20default\x20to\n\x20the\x20version\x20of\x20the\x20API\
    \x20used\x20to\x20make\x20such\x20call.\x20If\x20not\x20present\x20durin\
    g\x20a\n\x20ModifyPushConfig\x20call,\x20its\x20value\x20will\x20not\x20\
    be\x20changed.\x20GetSubscription\n\x20calls\x20will\x20always\x20return\
    \x20a\x20valid\x20version,\x20even\x20if\x20the\x20subscription\x20was\n\
    \x20created\x20without\x20this\x20attribute.\n\n\x20The\x20possible\x20v\
    alues\x20for\x20this\x20attribute\x20are:\n\n\x20*\x20`v1beta1`:\x20uses\
    \x20the\x20push\x20format\x20defined\x20in\x20the\x20v1beta1\x20Pub/Sub\
    \x20API.\n\x20*\x20`v1beta2`:\x20uses\x20the\x20push\x20format\x20define\
    d\x20in\x20the\x20v1beta2\x20Pub/Sub\x20API.\n\n\n\r\n\x05\x04\x0b\x02\
    \x01\x06\x12\x04\x91\x02\x02\x15\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\
    \x91\x02\x16\x20\n\r\n\x05\x04\x0b\x02\x01\x03\x12\x04\x91\x02#$\nB\n\
    \x02\x04\x0c\x12\x06\x95\x02\0\x9b\x02\x01\x1a4\x20A\x20message\x20and\
    \x20its\x20corresponding\x20acknowledgment\x20ID.\n\n\x0b\n\x03\x04\x0c\
    \x01\x12\x04\x95\x02\x08\x17\nH\n\x04\x04\x0c\x02\0\x12\x04\x97\x02\x02\
    \x14\x1a:\x20This\x20ID\x20can\x20be\x20used\x20to\x20acknowledge\x20the\
    \x20received\x20message.\n\n\r\n\x05\x04\x0c\x02\0\x05\x12\x04\x97\x02\
    \x02\x08\n\r\n\x05\x04\x0c\x02\0\x01\x12\x04\x97\x02\t\x0f\n\r\n\x05\x04\
    \x0c\x02\0\x03\x12\x04\x97\x02\x12\x13\n\x1c\n\x04\x04\x0c\x02\x01\x12\
    \x04\x9a\x02\x02\x1c\x1a\x0e\x20The\x20message.\n\n\r\n\x05\x04\x0c\x02\
    \x01\x06\x12\x04\x9a\x02\x02\x0f\n\r\n\x05\x04\x0c\x02\x01\x01\x12\x04\
    \x9a\x02\x10\x17\n\r\n\x05\x04\x0c\x02\x01\x03\x12\x04\x9a\x02\x1a\x1b\n\
    7\n\x02\x04\r\x12\x06\x9e\x02\0\xa1\x02\x01\x1a)\x20Request\x20for\x20th\
    e\x20GetSubscription\x20method.\n\n\x0b\n\x03\x04\r\x01\x12\x04\x9e\x02\
    \x08\x1e\n4\n\x04\x04\r\x02\0\x12\x04\xa0\x02\x02\x1a\x1a&\x20The\x20nam\
    e\x20of\x20the\x20subscription\x20to\x20get.\n\n\r\n\x05\x04\r\x02\0\x05\
    \x12\x04\xa0\x02\x02\x08\n\r\n\x05\x04\r\x02\0\x01\x12\x04\xa0\x02\t\x15\
    \n\r\n\x05\x04\r\x02\0\x03\x12\x04\xa0\x02\x18\x19\n9\n\x02\x04\x0e\x12\
    \x06\xa4\x02\0\xaf\x02\x01\x1a+\x20Request\x20for\x20the\x20ListSubscrip\
    tions\x20method.\n\n\x0b\n\x03\x04\x0e\x01\x12\x04\xa4\x02\x08\x20\nK\n\
    \x04\x04\x0e\x02\0\x12\x04\xa6\x02\x02\x15\x1a=\x20The\x20name\x20of\x20\
    the\x20cloud\x20project\x20that\x20subscriptions\x20belong\x20to.\n\n\r\
    \n\x05\x04\x0e\x02\0\x05\x12\x04\xa6\x02\x02\x08\n\r\n\x05\x04\x0e\x02\0\
    \x01\x12\x04\xa6\x02\t\x10\n\r\n\x05\x04\x0e\x02\0\x03\x12\x04\xa6\x02\
    \x13\x14\n:\n\x04\x04\x0e\x02\x01\x12\x04\xa9\x02\x02\x16\x1a,\x20Maximu\
    m\x20number\x20of\x20subscriptions\x20to\x20return.\n\n\r\n\x05\x04\x0e\
    \x02\x01\x05\x12\x04\xa9\x02\x02\x07\n\r\n\x05\x04\x0e\x02\x01\x01\x12\
    \x04\xa9\x02\x08\x11\n\r\n\x05\x04\x0e\x02\x01\x03\x12\x04\xa9\x02\x14\
    \x15\n\xce\x01\n\x04\x04\x0e\x02\x02\x12\x04\xae\x02\x02\x18\x1a\xbf\x01\
    \x20The\x20value\x20returned\x20by\x20the\x20last\x20ListSubscriptionsRe\
    sponse;\x20indicates\x20that\n\x20this\x20is\x20a\x20continuation\x20of\
    \x20a\x20prior\x20ListSubscriptions\x20call,\x20and\x20that\x20the\n\x20\
    system\x20should\x20return\x20the\x20next\x20page\x20of\x20data.\n\n\r\n\
    \x05\x04\x0e\x02\x02\x05\x12\x04\xae\x02\x02\x08\n\r\n\x05\x04\x0e\x02\
    \x02\x01\x12\x04\xae\x02\t\x13\n\r\n\x05\x04\x0e\x02\x02\x03\x12\x04\xae\
    \x02\x16\x17\n:\n\x02\x04\x0f\x12\x06\xb2\x02\0\xba\x02\x01\x1a,\x20Resp\
    onse\x20for\x20the\x20ListSubscriptions\x20method.\n\n\x0b\n\x03\x04\x0f\
    \x01\x12\x04\xb2\x02\x08!\n9\n\x04\x04\x0f\x02\0\x12\x04\xb4\x02\x02*\
    \x1a+\x20The\x20subscriptions\x20that\x20match\x20the\x20request.\n\n\r\
    \n\x05\x04\x0f\x02\0\x04\x12\x04\xb4\x02\x02\n\n\r\n\x05\x04\x0f\x02\0\
    \x06\x12\x04\xb4\x02\x0b\x17\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\xb4\x02\
    \x18%\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\xb4\x02()\n\xc0\x01\n\x04\x04\
    \x0f\x02\x01\x12\x04\xb9\x02\x02\x1d\x1a\xb1\x01\x20If\x20not\x20empty,\
    \x20indicates\x20that\x20there\x20may\x20be\x20more\x20subscriptions\x20\
    that\x20match\n\x20the\x20request;\x20this\x20value\x20should\x20be\x20p\
    assed\x20in\x20a\x20new\x20ListSubscriptionsRequest\n\x20to\x20get\x20mo\
    re\x20subscriptions.\n\n\r\n\x05\x04\x0f\x02\x01\x05\x12\x04\xb9\x02\x02\
    \x08\n\r\n\x05\x04\x0f\x02\x01\x01\x12\x04\xb9\x02\t\x18\n\r\n\x05\x04\
    \x0f\x02\x01\x03\x12\x04\xb9\x02\x1b\x1c\n:\n\x02\x04\x10\x12\x06\xbd\
    \x02\0\xc0\x02\x01\x1a,\x20Request\x20for\x20the\x20DeleteSubscription\
    \x20method.\n\n\x0b\n\x03\x04\x10\x01\x12\x04\xbd\x02\x08!\n+\n\x04\x04\
    \x10\x02\0\x12\x04\xbf\x02\x02\x1a\x1a\x1d\x20The\x20subscription\x20to\
    \x20delete.\n\n\r\n\x05\x04\x10\x02\0\x05\x12\x04\xbf\x02\x02\x08\n\r\n\
    \x05\x04\x10\x02\0\x01\x12\x04\xbf\x02\t\x15\n\r\n\x05\x04\x10\x02\0\x03\
    \x12\x04\xbf\x02\x18\x19\n8\n\x02\x04\x11\x12\x06\xc3\x02\0\xce\x02\x01\
    \x1a*\x20Request\x20for\x20the\x20ModifyPushConfig\x20method.\n\n\x0b\n\
    \x03\x04\x11\x01\x12\x04\xc3\x02\x08\x1f\n-\n\x04\x04\x11\x02\0\x12\x04\
    \xc5\x02\x02\x1a\x1a\x1f\x20The\x20name\x20of\x20the\x20subscription.\n\
    \n\r\n\x05\x04\x11\x02\0\x05\x12\x04\xc5\x02\x02\x08\n\r\n\x05\x04\x11\
    \x02\0\x01\x12\x04\xc5\x02\t\x15\n\r\n\x05\x04\x11\x02\0\x03\x12\x04\xc5\
    \x02\x18\x19\n\xa1\x02\n\x04\x04\x11\x02\x01\x12\x04\xcd\x02\x02\x1d\x1a\
    \x92\x02\x20The\x20push\x20configuration\x20for\x20future\x20deliveries.\
    \n\n\x20An\x20empty\x20pushConfig\x20indicates\x20that\x20the\x20Pub/Sub\
    \x20system\x20should\n\x20stop\x20pushing\x20messages\x20from\x20the\x20\
    given\x20subscription\x20and\x20allow\n\x20messages\x20to\x20be\x20pulle\
    d\x20and\x20acknowledged\x20-\x20effectively\x20pausing\n\x20the\x20subs\
    cription\x20if\x20Pull\x20is\x20not\x20called.\n\n\r\n\x05\x04\x11\x02\
    \x01\x06\x12\x04\xcd\x02\x02\x0c\n\r\n\x05\x04\x11\x02\x01\x01\x12\x04\
    \xcd\x02\r\x18\n\r\n\x05\x04\x11\x02\x01\x03\x12\x04\xcd\x02\x1b\x1c\n,\
    \n\x02\x04\x12\x12\x06\xd1\x02\0\xdf\x02\x01\x1a\x1e\x20Request\x20for\
    \x20the\x20Pull\x20method.\n\n\x0b\n\x03\x04\x12\x01\x12\x04\xd1\x02\x08\
    \x13\nF\n\x04\x04\x12\x02\0\x12\x04\xd3\x02\x02\x1a\x1a8\x20The\x20subsc\
    ription\x20from\x20which\x20messages\x20should\x20be\x20pulled.\n\n\r\n\
    \x05\x04\x12\x02\0\x05\x12\x04\xd3\x02\x02\x08\n\r\n\x05\x04\x12\x02\0\
    \x01\x12\x04\xd3\x02\t\x15\n\r\n\x05\x04\x12\x02\0\x03\x12\x04\xd3\x02\
    \x18\x19\n\xe4\x02\n\x04\x04\x12\x02\x01\x12\x04\xda\x02\x02\x1e\x1a\xd5\
    \x02\x20If\x20this\x20is\x20specified\x20as\x20true\x20the\x20system\x20\
    will\x20respond\x20immediately\x20even\x20if\n\x20it\x20is\x20not\x20abl\
    e\x20to\x20return\x20a\x20message\x20in\x20the\x20Pull\x20response.\x20O\
    therwise\x20the\n\x20system\x20is\x20allowed\x20to\x20wait\x20until\x20a\
    t\x20least\x20one\x20message\x20is\x20available\x20rather\n\x20than\x20r\
    eturning\x20no\x20messages.\x20The\x20client\x20may\x20cancel\x20the\x20\
    request\x20if\x20it\x20does\n\x20not\x20wish\x20to\x20wait\x20any\x20lon\
    ger\x20for\x20the\x20response.\n\n\r\n\x05\x04\x12\x02\x01\x05\x12\x04\
    \xda\x02\x02\x06\n\r\n\x05\x04\x12\x02\x01\x01\x12\x04\xda\x02\x07\x19\n\
    \r\n\x05\x04\x12\x02\x01\x03\x12\x04\xda\x02\x1c\x1d\n\x89\x01\n\x04\x04\
    \x12\x02\x02\x12\x04\xde\x02\x02\x19\x1a{\x20The\x20maximum\x20number\
    \x20of\x20messages\x20returned\x20for\x20this\x20request.\x20The\x20Pub/\
    Sub\n\x20system\x20may\x20return\x20fewer\x20than\x20the\x20number\x20sp\
    ecified.\n\n\r\n\x05\x04\x12\x02\x02\x05\x12\x04\xde\x02\x02\x07\n\r\n\
    \x05\x04\x12\x02\x02\x01\x12\x04\xde\x02\x08\x14\n\r\n\x05\x04\x12\x02\
    \x02\x03\x12\x04\xde\x02\x17\x18\n-\n\x02\x04\x13\x12\x06\xe2\x02\0\xe8\
    \x02\x01\x1a\x1f\x20Response\x20for\x20the\x20Pull\x20method.\n\n\x0b\n\
    \x03\x04\x13\x01\x12\x04\xe2\x02\x08\x14\n\x87\x02\n\x04\x04\x13\x02\0\
    \x12\x04\xe7\x02\x021\x1a\xf8\x01\x20Received\x20Pub/Sub\x20messages.\
    \x20The\x20Pub/Sub\x20system\x20will\x20return\x20zero\x20messages\x20if\
    \n\x20there\x20are\x20no\x20more\x20available\x20in\x20the\x20backlog.\
    \x20The\x20Pub/Sub\x20system\x20may\x20return\n\x20fewer\x20than\x20the\
    \x20maxMessages\x20requested\x20even\x20if\x20there\x20are\x20more\x20me\
    ssages\n\x20available\x20in\x20the\x20backlog.\n\n\r\n\x05\x04\x13\x02\0\
    \x04\x12\x04\xe7\x02\x02\n\n\r\n\x05\x04\x13\x02\0\x06\x12\x04\xe7\x02\
    \x0b\x1a\n\r\n\x05\x04\x13\x02\0\x01\x12\x04\xe7\x02\x1b,\n\r\n\x05\x04\
    \x13\x02\0\x03\x12\x04\xe7\x02/0\n9\n\x02\x04\x14\x12\x06\xeb\x02\0\xf8\
    \x02\x01\x1a+\x20Request\x20for\x20the\x20ModifyAckDeadline\x20method.\n\
    \n\x0b\n\x03\x04\x14\x01\x12\x04\xeb\x02\x08\x20\n-\n\x04\x04\x14\x02\0\
    \x12\x04\xed\x02\x02\x1a\x1a\x1f\x20The\x20name\x20of\x20the\x20subscrip\
    tion.\n\n\r\n\x05\x04\x14\x02\0\x05\x12\x04\xed\x02\x02\x08\n\r\n\x05\
    \x04\x14\x02\0\x01\x12\x04\xed\x02\t\x15\n\r\n\x05\x04\x14\x02\0\x03\x12\
    \x04\xed\x02\x18\x19\n&\n\x04\x04\x14\x02\x01\x12\x04\xf0\x02\x02\x14\
    \x1a\x18\x20The\x20acknowledgment\x20ID.\n\n\r\n\x05\x04\x14\x02\x01\x05\
    \x12\x04\xf0\x02\x02\x08\n\r\n\x05\x04\x14\x02\x01\x01\x12\x04\xf0\x02\t\
    \x0f\n\r\n\x05\x04\x14\x02\x01\x03\x12\x04\xf0\x02\x12\x13\n\xca\x02\n\
    \x04\x04\x14\x02\x02\x12\x04\xf7\x02\x02!\x1a\xbb\x02\x20The\x20new\x20a\
    ck\x20deadline\x20with\x20respect\x20to\x20the\x20time\x20this\x20reques\
    t\x20was\x20sent\x20to\x20the\n\x20Pub/Sub\x20system.\x20Must\x20be\x20>\
    =\x200.\x20For\x20example,\x20if\x20the\x20value\x20is\x2010,\x20the\x20\
    new\x20ack\n\x20deadline\x20will\x20expire\x2010\x20seconds\x20after\x20\
    the\x20ModifyAckDeadline\x20call\x20was\x20made.\n\x20Specifying\x20zero\
    \x20may\x20immediately\x20make\x20the\x20message\x20available\x20for\x20\
    another\x20pull\n\x20request.\n\n\r\n\x05\x04\x14\x02\x02\x05\x12\x04\
    \xf7\x02\x02\x07\n\r\n\x05\x04\x14\x02\x02\x01\x12\x04\xf7\x02\x08\x1c\n\
    \r\n\x05\x04\x14\x02\x02\x03\x12\x04\xf7\x02\x1f\x20\n3\n\x02\x04\x15\
    \x12\x06\xfb\x02\0\x82\x03\x01\x1a%\x20Request\x20for\x20the\x20Acknowle\
    dge\x20method.\n\n\x0b\n\x03\x04\x15\x01\x12\x04\xfb\x02\x08\x1a\nE\n\
    \x04\x04\x15\x02\0\x12\x04\xfd\x02\x02\x1a\x1a7\x20The\x20subscription\
    \x20whose\x20message\x20is\x20being\x20acknowledged.\n\n\r\n\x05\x04\x15\
    \x02\0\x05\x12\x04\xfd\x02\x02\x08\n\r\n\x05\x04\x15\x02\0\x01\x12\x04\
    \xfd\x02\t\x15\n\r\n\x05\x04\x15\x02\0\x03\x12\x04\xfd\x02\x18\x19\n\x9c\
    \x01\n\x04\x04\x15\x02\x01\x12\x04\x81\x03\x02\x1e\x1a\x8d\x01\x20The\
    \x20acknowledgment\x20ID\x20for\x20the\x20messages\x20being\x20acknowled\
    ged\x20that\x20was\x20returned\n\x20by\x20the\x20Pub/Sub\x20system\x20in\
    \x20the\x20Pull\x20response.\x20Must\x20not\x20be\x20empty.\n\n\r\n\x05\
    \x04\x15\x02\x01\x04\x12\x04\x81\x03\x02\n\n\r\n\x05\x04\x15\x02\x01\x05\
    \x12\x04\x81\x03\x0b\x11\n\r\n\x05\x04\x15\x02\x01\x01\x12\x04\x81\x03\
    \x12\x19\n\r\n\x05\x04\x15\x02\x01\x03\x12\x04\x81\x03\x1c\x1db\x06proto\
    3\
";

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