google-cloud-rust-raw 0.16.1

// 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/v1/schema.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 Schema {
    // message fields
    pub name: ::std::string::String,
    pub field_type: Schema_Type,
    pub definition: ::std::string::String,
    pub revision_id: ::std::string::String,
    pub revision_create_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .google.pubsub.v1.Schema.Type type = 2;


    pub fn get_field_type(&self) -> Schema_Type {
        self.field_type
    }
    pub fn clear_field_type(&mut self) {
        self.field_type = Schema_Type::TYPE_UNSPECIFIED;
    }

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

    // string definition = 3;


    pub fn get_definition(&self) -> &str {
        &self.definition
    }
    pub fn clear_definition(&mut self) {
        self.definition.clear();
    }

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

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

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

    // string revision_id = 4;


    pub fn get_revision_id(&self) -> &str {
        &self.revision_id
    }
    pub fn clear_revision_id(&mut self) {
        self.revision_id.clear();
    }

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

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

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

    // .google.protobuf.Timestamp revision_create_time = 6;


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

    pub fn has_revision_create_time(&self) -> bool {
        self.revision_create_time.is_some()
    }

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

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

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

impl ::protobuf::Message for Schema {
    fn is_initialized(&self) -> bool {
        for v in &self.revision_create_time {
            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_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.definition)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.revision_id)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.revision_create_time)?;
                },
                _ => {
                    ::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.field_type != Schema_Type::TYPE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.field_type);
        }
        if !self.definition.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.definition);
        }
        if !self.revision_id.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.revision_id);
        }
        if let Some(ref v) = self.revision_create_time.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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.field_type != Schema_Type::TYPE_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.field_type))?;
        }
        if !self.definition.is_empty() {
            os.write_string(3, &self.definition)?;
        }
        if !self.revision_id.is_empty() {
            os.write_string(4, &self.revision_id)?;
        }
        if let Some(ref v) = self.revision_create_time.as_ref() {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        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() -> Schema {
        Schema::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: &Schema| { &m.name },
                |m: &mut Schema| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Schema_Type>>(
                "type",
                |m: &Schema| { &m.field_type },
                |m: &mut Schema| { &mut m.field_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "definition",
                |m: &Schema| { &m.definition },
                |m: &mut Schema| { &mut m.definition },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "revision_id",
                |m: &Schema| { &m.revision_id },
                |m: &mut Schema| { &mut m.revision_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "revision_create_time",
                |m: &Schema| { &m.revision_create_time },
                |m: &mut Schema| { &mut m.revision_create_time },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Schema>(
                "Schema",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for Schema {
    fn clear(&mut self) {
        self.name.clear();
        self.field_type = Schema_Type::TYPE_UNSPECIFIED;
        self.definition.clear();
        self.revision_id.clear();
        self.revision_create_time.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Schema_Type {
    TYPE_UNSPECIFIED = 0,
    PROTOCOL_BUFFER = 1,
    AVRO = 2,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<Schema_Type> {
        match value {
            0 => ::std::option::Option::Some(Schema_Type::TYPE_UNSPECIFIED),
            1 => ::std::option::Option::Some(Schema_Type::PROTOCOL_BUFFER),
            2 => ::std::option::Option::Some(Schema_Type::AVRO),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Schema_Type] = &[
            Schema_Type::TYPE_UNSPECIFIED,
            Schema_Type::PROTOCOL_BUFFER,
            Schema_Type::AVRO,
        ];
        values
    }

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

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

impl ::std::default::Default for Schema_Type {
    fn default() -> Self {
        Schema_Type::TYPE_UNSPECIFIED
    }
}

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

#[derive(PartialEq,Clone,Default)]
pub struct CreateSchemaRequest {
    // message fields
    pub parent: ::std::string::String,
    pub schema: ::protobuf::SingularPtrField<Schema>,
    pub schema_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // .google.pubsub.v1.Schema schema = 2;


    pub fn get_schema(&self) -> &Schema {
        self.schema.as_ref().unwrap_or_else(|| <Schema as ::protobuf::Message>::default_instance())
    }
    pub fn clear_schema(&mut self) {
        self.schema.clear();
    }

    pub fn has_schema(&self) -> bool {
        self.schema.is_some()
    }

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

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

    // Take field
    pub fn take_schema(&mut self) -> Schema {
        self.schema.take().unwrap_or_else(|| Schema::new())
    }

    // string schema_id = 3;


    pub fn get_schema_id(&self) -> &str {
        &self.schema_id
    }
    pub fn clear_schema_id(&mut self) {
        self.schema_id.clear();
    }

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

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

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

impl ::protobuf::Message for CreateSchemaRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.schema {
            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.parent)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.schema)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.schema_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.parent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.parent);
        }
        if let Some(ref v) = self.schema.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.schema_id.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.schema_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.parent.is_empty() {
            os.write_string(1, &self.parent)?;
        }
        if let Some(ref v) = self.schema.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)?;
        }
        if !self.schema_id.is_empty() {
            os.write_string(3, &self.schema_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() -> CreateSchemaRequest {
        CreateSchemaRequest::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>(
                "parent",
                |m: &CreateSchemaRequest| { &m.parent },
                |m: &mut CreateSchemaRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Schema>>(
                "schema",
                |m: &CreateSchemaRequest| { &m.schema },
                |m: &mut CreateSchemaRequest| { &mut m.schema },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "schema_id",
                |m: &CreateSchemaRequest| { &m.schema_id },
                |m: &mut CreateSchemaRequest| { &mut m.schema_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CreateSchemaRequest>(
                "CreateSchemaRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CreateSchemaRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.schema.clear();
        self.schema_id.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // .google.pubsub.v1.SchemaView view = 2;


    pub fn get_view(&self) -> SchemaView {
        self.view
    }
    pub fn clear_view(&mut self) {
        self.view = SchemaView::SCHEMA_VIEW_UNSPECIFIED;
    }

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

impl ::protobuf::Message for GetSchemaRequest {
    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)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.view, 2, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if self.view != SchemaView::SCHEMA_VIEW_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.view);
        }
        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.view != SchemaView::SCHEMA_VIEW_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.view))?;
        }
        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() -> GetSchemaRequest {
        GetSchemaRequest::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: &GetSchemaRequest| { &m.name },
                |m: &mut GetSchemaRequest| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SchemaView>>(
                "view",
                |m: &GetSchemaRequest| { &m.view },
                |m: &mut GetSchemaRequest| { &mut m.view },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetSchemaRequest>(
                "GetSchemaRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for GetSchemaRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.view = SchemaView::SCHEMA_VIEW_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListSchemasRequest {
    // message fields
    pub parent: ::std::string::String,
    pub view: SchemaView,
    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 ListSchemasRequest {
    fn default() -> &'a ListSchemasRequest {
        <ListSchemasRequest as ::protobuf::Message>::default_instance()
    }
}

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // .google.pubsub.v1.SchemaView view = 2;


    pub fn get_view(&self) -> SchemaView {
        self.view
    }
    pub fn clear_view(&mut self) {
        self.view = SchemaView::SCHEMA_VIEW_UNSPECIFIED;
    }

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

    // int32 page_size = 3;


    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 = 4;


    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 ListSchemasRequest {
    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.parent)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.view, 2, &mut self.unknown_fields)?
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.page_size = tmp;
                },
                4 => {
                    ::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.parent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.parent);
        }
        if self.view != SchemaView::SCHEMA_VIEW_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.view);
        }
        if self.page_size != 0 {
            my_size += ::protobuf::rt::value_size(3, self.page_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &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.parent.is_empty() {
            os.write_string(1, &self.parent)?;
        }
        if self.view != SchemaView::SCHEMA_VIEW_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.view))?;
        }
        if self.page_size != 0 {
            os.write_int32(3, self.page_size)?;
        }
        if !self.page_token.is_empty() {
            os.write_string(4, &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() -> ListSchemasRequest {
        ListSchemasRequest::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>(
                "parent",
                |m: &ListSchemasRequest| { &m.parent },
                |m: &mut ListSchemasRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SchemaView>>(
                "view",
                |m: &ListSchemasRequest| { &m.view },
                |m: &mut ListSchemasRequest| { &mut m.view },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListSchemasRequest| { &m.page_size },
                |m: &mut ListSchemasRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListSchemasRequest| { &m.page_token },
                |m: &mut ListSchemasRequest| { &mut m.page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSchemasRequest>(
                "ListSchemasRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListSchemasRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.view = SchemaView::SCHEMA_VIEW_UNSPECIFIED;
        self.page_size = 0;
        self.page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListSchemasResponse {
    // message fields
    pub schemas: ::protobuf::RepeatedField<Schema>,
    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 ListSchemasResponse {
    fn default() -> &'a ListSchemasResponse {
        <ListSchemasResponse as ::protobuf::Message>::default_instance()
    }
}

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

    // repeated .google.pubsub.v1.Schema schemas = 1;


    pub fn get_schemas(&self) -> &[Schema] {
        &self.schemas
    }
    pub fn clear_schemas(&mut self) {
        self.schemas.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_schemas(&mut self) -> &mut ::protobuf::RepeatedField<Schema> {
        &mut self.schemas
    }

    // Take field
    pub fn take_schemas(&mut self) -> ::protobuf::RepeatedField<Schema> {
        ::std::mem::replace(&mut self.schemas, ::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 ListSchemasResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.schemas {
            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.schemas)?;
                },
                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.schemas {
            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.schemas {
            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() -> ListSchemasResponse {
        ListSchemasResponse::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<Schema>>(
                "schemas",
                |m: &ListSchemasResponse| { &m.schemas },
                |m: &mut ListSchemasResponse| { &mut m.schemas },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListSchemasResponse| { &m.next_page_token },
                |m: &mut ListSchemasResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSchemasResponse>(
                "ListSchemasResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListSchemaRevisionsRequest {
    // message fields
    pub name: ::std::string::String,
    pub view: SchemaView,
    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 ListSchemaRevisionsRequest {
    fn default() -> &'a ListSchemaRevisionsRequest {
        <ListSchemaRevisionsRequest as ::protobuf::Message>::default_instance()
    }
}

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

    // .google.pubsub.v1.SchemaView view = 2;


    pub fn get_view(&self) -> SchemaView {
        self.view
    }
    pub fn clear_view(&mut self) {
        self.view = SchemaView::SCHEMA_VIEW_UNSPECIFIED;
    }

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

    // int32 page_size = 3;


    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 = 4;


    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 ListSchemaRevisionsRequest {
    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)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.view, 2, &mut self.unknown_fields)?
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.page_size = tmp;
                },
                4 => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if self.view != SchemaView::SCHEMA_VIEW_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.view);
        }
        if self.page_size != 0 {
            my_size += ::protobuf::rt::value_size(3, self.page_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.view != SchemaView::SCHEMA_VIEW_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.view))?;
        }
        if self.page_size != 0 {
            os.write_int32(3, self.page_size)?;
        }
        if !self.page_token.is_empty() {
            os.write_string(4, &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() -> ListSchemaRevisionsRequest {
        ListSchemaRevisionsRequest::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: &ListSchemaRevisionsRequest| { &m.name },
                |m: &mut ListSchemaRevisionsRequest| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SchemaView>>(
                "view",
                |m: &ListSchemaRevisionsRequest| { &m.view },
                |m: &mut ListSchemaRevisionsRequest| { &mut m.view },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListSchemaRevisionsRequest| { &m.page_size },
                |m: &mut ListSchemaRevisionsRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListSchemaRevisionsRequest| { &m.page_token },
                |m: &mut ListSchemaRevisionsRequest| { &mut m.page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSchemaRevisionsRequest>(
                "ListSchemaRevisionsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListSchemaRevisionsRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.view = SchemaView::SCHEMA_VIEW_UNSPECIFIED;
        self.page_size = 0;
        self.page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListSchemaRevisionsResponse {
    // message fields
    pub schemas: ::protobuf::RepeatedField<Schema>,
    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 ListSchemaRevisionsResponse {
    fn default() -> &'a ListSchemaRevisionsResponse {
        <ListSchemaRevisionsResponse as ::protobuf::Message>::default_instance()
    }
}

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

    // repeated .google.pubsub.v1.Schema schemas = 1;


    pub fn get_schemas(&self) -> &[Schema] {
        &self.schemas
    }
    pub fn clear_schemas(&mut self) {
        self.schemas.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_schemas(&mut self) -> &mut ::protobuf::RepeatedField<Schema> {
        &mut self.schemas
    }

    // Take field
    pub fn take_schemas(&mut self) -> ::protobuf::RepeatedField<Schema> {
        ::std::mem::replace(&mut self.schemas, ::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 ListSchemaRevisionsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.schemas {
            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.schemas)?;
                },
                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.schemas {
            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.schemas {
            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() -> ListSchemaRevisionsResponse {
        ListSchemaRevisionsResponse::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<Schema>>(
                "schemas",
                |m: &ListSchemaRevisionsResponse| { &m.schemas },
                |m: &mut ListSchemaRevisionsResponse| { &mut m.schemas },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListSchemaRevisionsResponse| { &m.next_page_token },
                |m: &mut ListSchemaRevisionsResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSchemaRevisionsResponse>(
                "ListSchemaRevisionsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // .google.pubsub.v1.Schema schema = 2;


    pub fn get_schema(&self) -> &Schema {
        self.schema.as_ref().unwrap_or_else(|| <Schema as ::protobuf::Message>::default_instance())
    }
    pub fn clear_schema(&mut self) {
        self.schema.clear();
    }

    pub fn has_schema(&self) -> bool {
        self.schema.is_some()
    }

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

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

    // Take field
    pub fn take_schema(&mut self) -> Schema {
        self.schema.take().unwrap_or_else(|| Schema::new())
    }
}

impl ::protobuf::Message for CommitSchemaRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.schema {
            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_message_into(wire_type, is, &mut self.schema)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.schema.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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if let Some(ref v) = self.schema.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() -> CommitSchemaRequest {
        CommitSchemaRequest::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: &CommitSchemaRequest| { &m.name },
                |m: &mut CommitSchemaRequest| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Schema>>(
                "schema",
                |m: &CommitSchemaRequest| { &m.schema },
                |m: &mut CommitSchemaRequest| { &mut m.schema },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CommitSchemaRequest>(
                "CommitSchemaRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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


    pub fn get_revision_id(&self) -> &str {
        &self.revision_id
    }
    pub fn clear_revision_id(&mut self) {
        self.revision_id.clear();
    }

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

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

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

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

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

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

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

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

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

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

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


    pub fn get_revision_id(&self) -> &str {
        &self.revision_id
    }
    pub fn clear_revision_id(&mut self) {
        self.revision_id.clear();
    }

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct DeleteSchemaRequest {
    // 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 DeleteSchemaRequest {
    fn default() -> &'a DeleteSchemaRequest {
        <DeleteSchemaRequest as ::protobuf::Message>::default_instance()
    }
}

impl DeleteSchemaRequest {
    pub fn new() -> DeleteSchemaRequest {
        ::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 DeleteSchemaRequest {
    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() -> DeleteSchemaRequest {
        DeleteSchemaRequest::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: &DeleteSchemaRequest| { &m.name },
                |m: &mut DeleteSchemaRequest| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteSchemaRequest>(
                "DeleteSchemaRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // .google.pubsub.v1.Schema schema = 2;


    pub fn get_schema(&self) -> &Schema {
        self.schema.as_ref().unwrap_or_else(|| <Schema as ::protobuf::Message>::default_instance())
    }
    pub fn clear_schema(&mut self) {
        self.schema.clear();
    }

    pub fn has_schema(&self) -> bool {
        self.schema.is_some()
    }

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

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

    // Take field
    pub fn take_schema(&mut self) -> Schema {
        self.schema.take().unwrap_or_else(|| Schema::new())
    }
}

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

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

impl ::protobuf::Clear for ValidateSchemaRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.schema.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ValidateSchemaResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

impl ::protobuf::Message for ValidateSchemaResponse {
    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 {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::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<()> {
        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() -> ValidateSchemaResponse {
        ValidateSchemaResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ValidateSchemaResponse>(
                "ValidateSchemaResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ValidateMessageRequest {
    // message fields
    pub parent: ::std::string::String,
    pub message: ::std::vec::Vec<u8>,
    pub encoding: Encoding,
    // message oneof groups
    pub schema_spec: ::std::option::Option<ValidateMessageRequest_oneof_schema_spec>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum ValidateMessageRequest_oneof_schema_spec {
    name(::std::string::String),
    schema(Schema),
}

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // string name = 2;


    pub fn get_name(&self) -> &str {
        match self.schema_spec {
            ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::name(ref v)) => v,
            _ => "",
        }
    }
    pub fn clear_name(&mut self) {
        self.schema_spec = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        match self.schema_spec {
            ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::name(..)) => true,
            _ => false,
        }
    }

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

    // Mutable pointer to the field.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::name(_)) = self.schema_spec {
        } else {
            self.schema_spec = ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::name(::std::string::String::new()));
        }
        match self.schema_spec {
            ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::name(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        if self.has_name() {
            match self.schema_spec.take() {
                ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::name(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    // .google.pubsub.v1.Schema schema = 3;


    pub fn get_schema(&self) -> &Schema {
        match self.schema_spec {
            ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::schema(ref v)) => v,
            _ => <Schema as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_schema(&mut self) {
        self.schema_spec = ::std::option::Option::None;
    }

    pub fn has_schema(&self) -> bool {
        match self.schema_spec {
            ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::schema(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_schema(&mut self, v: Schema) {
        self.schema_spec = ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::schema(v))
    }

    // Mutable pointer to the field.
    pub fn mut_schema(&mut self) -> &mut Schema {
        if let ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::schema(_)) = self.schema_spec {
        } else {
            self.schema_spec = ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::schema(Schema::new()));
        }
        match self.schema_spec {
            ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::schema(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_schema(&mut self) -> Schema {
        if self.has_schema() {
            match self.schema_spec.take() {
                ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::schema(v)) => v,
                _ => panic!(),
            }
        } else {
            Schema::new()
        }
    }

    // bytes message = 4;


    pub fn get_message(&self) -> &[u8] {
        &self.message
    }
    pub fn clear_message(&mut self) {
        self.message.clear();
    }

    // Param is passed by value, moved
    pub fn set_message(&mut self, v: ::std::vec::Vec<u8>) {
        self.message = 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 ::std::vec::Vec<u8> {
        &mut self.message
    }

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

    // .google.pubsub.v1.Encoding encoding = 5;


    pub fn get_encoding(&self) -> Encoding {
        self.encoding
    }
    pub fn clear_encoding(&mut self) {
        self.encoding = Encoding::ENCODING_UNSPECIFIED;
    }

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

impl ::protobuf::Message for ValidateMessageRequest {
    fn is_initialized(&self) -> bool {
        if let Some(ValidateMessageRequest_oneof_schema_spec::schema(ref v)) = self.schema_spec {
            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.parent)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.schema_spec = ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::name(is.read_string()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.schema_spec = ::std::option::Option::Some(ValidateMessageRequest_oneof_schema_spec::schema(is.read_message()?));
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.message)?;
                },
                5 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.encoding, 5, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.parent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.parent);
        }
        if !self.message.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.message);
        }
        if self.encoding != Encoding::ENCODING_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(5, self.encoding);
        }
        if let ::std::option::Option::Some(ref v) = self.schema_spec {
            match v {
                &ValidateMessageRequest_oneof_schema_spec::name(ref v) => {
                    my_size += ::protobuf::rt::string_size(2, &v);
                },
                &ValidateMessageRequest_oneof_schema_spec::schema(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.parent.is_empty() {
            os.write_string(1, &self.parent)?;
        }
        if !self.message.is_empty() {
            os.write_bytes(4, &self.message)?;
        }
        if self.encoding != Encoding::ENCODING_UNSPECIFIED {
            os.write_enum(5, ::protobuf::ProtobufEnum::value(&self.encoding))?;
        }
        if let ::std::option::Option::Some(ref v) = self.schema_spec {
            match v {
                &ValidateMessageRequest_oneof_schema_spec::name(ref v) => {
                    os.write_string(2, v)?;
                },
                &ValidateMessageRequest_oneof_schema_spec::schema(ref v) => {
                    os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ValidateMessageRequest {
        ValidateMessageRequest::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>(
                "parent",
                |m: &ValidateMessageRequest| { &m.parent },
                |m: &mut ValidateMessageRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
                "name",
                ValidateMessageRequest::has_name,
                ValidateMessageRequest::get_name,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Schema>(
                "schema",
                ValidateMessageRequest::has_schema,
                ValidateMessageRequest::get_schema,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "message",
                |m: &ValidateMessageRequest| { &m.message },
                |m: &mut ValidateMessageRequest| { &mut m.message },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Encoding>>(
                "encoding",
                |m: &ValidateMessageRequest| { &m.encoding },
                |m: &mut ValidateMessageRequest| { &mut m.encoding },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ValidateMessageRequest>(
                "ValidateMessageRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ValidateMessageRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.schema_spec = ::std::option::Option::None;
        self.schema_spec = ::std::option::Option::None;
        self.message.clear();
        self.encoding = Encoding::ENCODING_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ValidateMessageResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

impl ::protobuf::Message for ValidateMessageResponse {
    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 {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::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<()> {
        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() -> ValidateMessageResponse {
        ValidateMessageResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ValidateMessageResponse>(
                "ValidateMessageResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum SchemaView {
    SCHEMA_VIEW_UNSPECIFIED = 0,
    BASIC = 1,
    FULL = 2,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SchemaView> {
        match value {
            0 => ::std::option::Option::Some(SchemaView::SCHEMA_VIEW_UNSPECIFIED),
            1 => ::std::option::Option::Some(SchemaView::BASIC),
            2 => ::std::option::Option::Some(SchemaView::FULL),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SchemaView] = &[
            SchemaView::SCHEMA_VIEW_UNSPECIFIED,
            SchemaView::BASIC,
            SchemaView::FULL,
        ];
        values
    }

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

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

impl ::std::default::Default for SchemaView {
    fn default() -> Self {
        SchemaView::SCHEMA_VIEW_UNSPECIFIED
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Encoding {
    ENCODING_UNSPECIFIED = 0,
    JSON = 1,
    BINARY = 2,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<Encoding> {
        match value {
            0 => ::std::option::Option::Some(Encoding::ENCODING_UNSPECIFIED),
            1 => ::std::option::Option::Some(Encoding::JSON),
            2 => ::std::option::Option::Some(Encoding::BINARY),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Encoding] = &[
            Encoding::ENCODING_UNSPECIFIED,
            Encoding::JSON,
            Encoding::BINARY,
        ];
        values
    }

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

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

impl ::std::default::Default for Encoding {
    fn default() -> Self {
        Encoding::ENCODING_UNSPECIFIED
    }
}

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x1dgoogle/pubsub/v1/schema.proto\x12\x10google.pubsub.v1\x1a\x1cgoogl\
    e/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api\
    /field_behavior.proto\x1a\x19google/api/resource.proto\x1a\x1bgoogle/pro\
    tobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xf5\x02\n\x06\
    Schema\x12\x17\n\x04name\x18\x01\x20\x01(\tR\x04nameB\x03\xe0A\x02\x121\
    \n\x04type\x18\x02\x20\x01(\x0e2\x1d.google.pubsub.v1.Schema.TypeR\x04ty\
    pe\x12\x1e\n\ndefinition\x18\x03\x20\x01(\tR\ndefinition\x12'\n\x0brevis\
    ion_id\x18\x04\x20\x01(\tR\nrevisionIdB\x06\xe0A\x05\xe0A\x03\x12Q\n\x14\
    revision_create_time\x18\x06\x20\x01(\x0b2\x1a.google.protobuf.Timestamp\
    R\x12revisionCreateTimeB\x03\xe0A\x03\";\n\x04Type\x12\x14\n\x10TYPE_UNS\
    PECIFIED\x10\0\x12\x13\n\x0fPROTOCOL_BUFFER\x10\x01\x12\x08\n\x04AVRO\
    \x10\x02:F\xeaAC\n\x1cpubsub.googleapis.com/Schema\x12#projects/{project\
    }/schemas/{schema}\"\xa7\x01\n\x13CreateSchemaRequest\x12<\n\x06parent\
    \x18\x01\x20\x01(\tR\x06parentB$\xfaA\x1e\x12\x1cpubsub.googleapis.com/S\
    chema\xe0A\x02\x125\n\x06schema\x18\x02\x20\x01(\x0b2\x18.google.pubsub.\
    v1.SchemaR\x06schemaB\x03\xe0A\x02\x12\x1b\n\tschema_id\x18\x03\x20\x01(\
    \tR\x08schemaId\"~\n\x10GetSchemaRequest\x128\n\x04name\x18\x01\x20\x01(\
    \tR\x04nameB$\xfaA\x1e\n\x1cpubsub.googleapis.com/Schema\xe0A\x02\x120\n\
    \x04view\x18\x02\x20\x01(\x0e2\x1c.google.pubsub.v1.SchemaViewR\x04view\
    \"\xcf\x01\n\x12ListSchemasRequest\x12K\n\x06parent\x18\x01\x20\x01(\tR\
    \x06parentB3\xfaA-\n+cloudresourcemanager.googleapis.com/Project\xe0A\
    \x02\x120\n\x04view\x18\x02\x20\x01(\x0e2\x1c.google.pubsub.v1.SchemaVie\
    wR\x04view\x12\x1b\n\tpage_size\x18\x03\x20\x01(\x05R\x08pageSize\x12\
    \x1d\n\npage_token\x18\x04\x20\x01(\tR\tpageToken\"q\n\x13ListSchemasRes\
    ponse\x122\n\x07schemas\x18\x01\x20\x03(\x0b2\x18.google.pubsub.v1.Schem\
    aR\x07schemas\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageTok\
    en\"\xc4\x01\n\x1aListSchemaRevisionsRequest\x128\n\x04name\x18\x01\x20\
    \x01(\tR\x04nameB$\xfaA\x1e\n\x1cpubsub.googleapis.com/Schema\xe0A\x02\
    \x120\n\x04view\x18\x02\x20\x01(\x0e2\x1c.google.pubsub.v1.SchemaViewR\
    \x04view\x12\x1b\n\tpage_size\x18\x03\x20\x01(\x05R\x08pageSize\x12\x1d\
    \n\npage_token\x18\x04\x20\x01(\tR\tpageToken\"y\n\x1bListSchemaRevision\
    sResponse\x122\n\x07schemas\x18\x01\x20\x03(\x0b2\x18.google.pubsub.v1.S\
    chemaR\x07schemas\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPag\
    eToken\"\x86\x01\n\x13CommitSchemaRequest\x128\n\x04name\x18\x01\x20\x01\
    (\tR\x04nameB$\xfaA\x1e\n\x1cpubsub.googleapis.com/Schema\xe0A\x02\x125\
    \n\x06schema\x18\x02\x20\x01(\x0b2\x18.google.pubsub.v1.SchemaR\x06schem\
    aB\x03\xe0A\x02\"w\n\x15RollbackSchemaRequest\x128\n\x04name\x18\x01\x20\
    \x01(\tR\x04nameB$\xfaA\x1e\n\x1cpubsub.googleapis.com/Schema\xe0A\x02\
    \x12$\n\x0brevision_id\x18\x02\x20\x01(\tR\nrevisionIdB\x03\xe0A\x02\"\
    \x7f\n\x1bDeleteSchemaRevisionRequest\x128\n\x04name\x18\x01\x20\x01(\tR\
    \x04nameB$\xfaA\x1e\n\x1cpubsub.googleapis.com/Schema\xe0A\x02\x12&\n\
    \x0brevision_id\x18\x02\x20\x01(\tR\nrevisionIdB\x05\x18\x01\xe0A\x01\"O\
    \n\x13DeleteSchemaRequest\x128\n\x04name\x18\x01\x20\x01(\tR\x04nameB$\
    \xfaA\x1e\n\x1cpubsub.googleapis.com/Schema\xe0A\x02\"\x9b\x01\n\x15Vali\
    dateSchemaRequest\x12K\n\x06parent\x18\x01\x20\x01(\tR\x06parentB3\xfaA-\
    \n+cloudresourcemanager.googleapis.com/Project\xe0A\x02\x125\n\x06schema\
    \x18\x02\x20\x01(\x0b2\x18.google.pubsub.v1.SchemaR\x06schemaB\x03\xe0A\
    \x02\"\x18\n\x16ValidateSchemaResponse\"\xb3\x02\n\x16ValidateMessageReq\
    uest\x12K\n\x06parent\x18\x01\x20\x01(\tR\x06parentB3\xfaA-\n+cloudresou\
    rcemanager.googleapis.com/Project\xe0A\x02\x127\n\x04name\x18\x02\x20\
    \x01(\tH\0R\x04nameB!\xfaA\x1e\n\x1cpubsub.googleapis.com/Schema\x122\n\
    \x06schema\x18\x03\x20\x01(\x0b2\x18.google.pubsub.v1.SchemaH\0R\x06sche\
    ma\x12\x18\n\x07message\x18\x04\x20\x01(\x0cR\x07message\x126\n\x08encod\
    ing\x18\x05\x20\x01(\x0e2\x1a.google.pubsub.v1.EncodingR\x08encodingB\r\
    \n\x0bschema_spec\"\x19\n\x17ValidateMessageResponse*>\n\nSchemaView\x12\
    \x1b\n\x17SCHEMA_VIEW_UNSPECIFIED\x10\0\x12\t\n\x05BASIC\x10\x01\x12\x08\
    \n\x04FULL\x10\x02*:\n\x08Encoding\x12\x18\n\x14ENCODING_UNSPECIFIED\x10\
    \0\x12\x08\n\x04JSON\x10\x01\x12\n\n\x06BINARY\x10\x022\x88\r\n\rSchemaS\
    ervice\x12\x9a\x01\n\x0cCreateSchema\x12%.google.pubsub.v1.CreateSchemaR\
    equest\x1a\x18.google.pubsub.v1.Schema\"I\x82\xd3\xe4\x93\x02)\"\x1f/v1/\
    {parent=projects/*}/schemas:\x06schema\xdaA\x17parent,schema,schema_id\
    \x12y\n\tGetSchema\x12\".google.pubsub.v1.GetSchemaRequest\x1a\x18.googl\
    e.pubsub.v1.Schema\".\x82\xd3\xe4\x93\x02!\x12\x1f/v1/{name=projects/*/s\
    chemas/*}\xdaA\x04name\x12\x8c\x01\n\x0bListSchemas\x12$.google.pubsub.v\
    1.ListSchemasRequest\x1a%.google.pubsub.v1.ListSchemasResponse\"0\x82\
    \xd3\xe4\x93\x02!\x12\x1f/v1/{parent=projects/*}/schemas\xdaA\x06parent\
    \x12\xb0\x01\n\x13ListSchemaRevisions\x12,.google.pubsub.v1.ListSchemaRe\
    visionsRequest\x1a-.google.pubsub.v1.ListSchemaRevisionsResponse\"<\x82\
    \xd3\xe4\x93\x02/\x12-/v1/{name=projects/*/schemas/*}:listRevisions\xdaA\
    \x04name\x12\x90\x01\n\x0cCommitSchema\x12%.google.pubsub.v1.CommitSchem\
    aRequest\x1a\x18.google.pubsub.v1.Schema\"?\x82\xd3\xe4\x93\x02+\"&/v1/{\
    name=projects/*/schemas/*}:commit:\x01*\xdaA\x0bname,schema\x12\x9b\x01\
    \n\x0eRollbackSchema\x12'.google.pubsub.v1.RollbackSchemaRequest\x1a\x18\
    .google.pubsub.v1.Schema\"F\x82\xd3\xe4\x93\x02-\"(/v1/{name=projects/*/\
    schemas/*}:rollback:\x01*\xdaA\x10name,revision_id\x12\xaa\x01\n\x14Dele\
    teSchemaRevision\x12-.google.pubsub.v1.DeleteSchemaRevisionRequest\x1a\
    \x18.google.pubsub.v1.Schema\"I\x82\xd3\xe4\x93\x020*./v1/{name=projects\
    /*/schemas/*}:deleteRevision\xdaA\x10name,revision_id\x12}\n\x0cDeleteSc\
    hema\x12%.google.pubsub.v1.DeleteSchemaRequest\x1a\x16.google.protobuf.E\
    mpty\".\x82\xd3\xe4\x93\x02!*\x1f/v1/{name=projects/*/schemas/*}\xdaA\
    \x04name\x12\xa8\x01\n\x0eValidateSchema\x12'.google.pubsub.v1.ValidateS\
    chemaRequest\x1a(.google.pubsub.v1.ValidateSchemaResponse\"C\x82\xd3\xe4\
    \x93\x02-\"(/v1/{parent=projects/*}/schemas:validate:\x01*\xdaA\rparent,\
    schema\x12\xa2\x01\n\x0fValidateMessage\x12(.google.pubsub.v1.ValidateMe\
    ssageRequest\x1a).google.pubsub.v1.ValidateMessageResponse\":\x82\xd3\
    \xe4\x93\x024\"//v1/{parent=projects/*}/schemas:validateMessage:\x01*\
    \x1ap\xd2AUhttps://www.googleapis.com/auth/cloud-platform,https://www.go\
    ogleapis.com/auth/pubsub\xcaA\x15pubsub.googleapis.comB\xaa\x01\n\x14com\
    .google.pubsub.v1B\x0bSchemaProtoP\x01Z2cloud.google.com/go/pubsub/apiv1\
    /pubsubpb;pubsubpb\xf8\x01\x01\xaa\x02\x16Google.Cloud.PubSub.V1\xca\x02\
    \x16Google\\Cloud\\PubSub\\V1\xea\x02\x19Google::Cloud::PubSub::V1J\xf8X\
    \n\x07\x12\x05\x0e\0\x99\x03\x01\n\xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\
    \xb1\x04\x20Copyright\x202023\x20Google\x20LLC\n\n\x20Licensed\x20under\
    \x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"License\");\
    \n\x20you\x20may\x20not\x20use\x20this\x20file\x20except\x20in\x20compli\
    ance\x20with\x20the\x20License.\n\x20You\x20may\x20obtain\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,\x20software\n\x20distrib\
    uted\x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\
    \x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\
    \x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\
    \x20License\x20for\x20the\x20specific\x20language\x20governing\x20permis\
    sions\x20and\n\x20limitations\x20under\x20the\x20License.\n\n\x08\n\x01\
    \x02\x12\x03\x10\0\x19\n\t\n\x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\
    \x12\x03\x13\0!\n\t\n\x02\x03\x02\x12\x03\x14\0)\n\t\n\x02\x03\x03\x12\
    \x03\x15\0#\n\t\n\x02\x03\x04\x12\x03\x16\0%\n\t\n\x02\x03\x05\x12\x03\
    \x17\0)\n\x08\n\x01\x08\x12\x03\x19\0\x1f\n\t\n\x02\x08\x1f\x12\x03\x19\
    \0\x1f\n\x08\n\x01\x08\x12\x03\x1a\03\n\t\n\x02\x08%\x12\x03\x1a\03\n\
    \x08\n\x01\x08\x12\x03\x1b\0I\n\t\n\x02\x08\x0b\x12\x03\x1b\0I\n\x08\n\
    \x01\x08\x12\x03\x1c\0\"\n\t\n\x02\x08\n\x12\x03\x1c\0\"\n\x08\n\x01\x08\
    \x12\x03\x1d\0,\n\t\n\x02\x08\x08\x12\x03\x1d\0,\n\x08\n\x01\x08\x12\x03\
    \x1e\0-\n\t\n\x02\x08\x01\x12\x03\x1e\0-\n\x08\n\x01\x08\x12\x03\x1f\03\
    \n\t\n\x02\x08)\x12\x03\x1f\03\n\x08\n\x01\x08\x12\x03\x20\02\n\t\n\x02\
    \x08-\x12\x03\x20\02\n:\n\x02\x06\0\x12\x04#\0~\x01\x1a.\x20Service\x20f\
    or\x20doing\x20schema-related\x20operations.\n\n\n\n\x03\x06\0\x01\x12\
    \x03#\x08\x15\n\n\n\x03\x06\0\x03\x12\x03$\x02=\n\x0c\n\x05\x06\0\x03\
    \x99\x08\x12\x03$\x02=\n\x0b\n\x03\x06\0\x03\x12\x04%\x02'/\n\r\n\x05\
    \x06\0\x03\x9a\x08\x12\x04%\x02'/\n!\n\x04\x06\0\x02\0\x12\x04*\x020\x03\
    \x1a\x13\x20Creates\x20a\x20schema.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\
    \x03*\x06\x12\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03*\x13&\n\x0c\n\x05\x06\
    \0\x02\0\x03\x12\x03*17\n\r\n\x05\x06\0\x02\0\x04\x12\x04+\x04.\x06\n\
    \x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04+\x04.\x06\n\x0c\n\x05\x06\
    \0\x02\0\x04\x12\x03/\x04E\n\x0f\n\x08\x06\0\x02\0\x04\x9b\x08\0\x12\x03\
    /\x04E\n\x1e\n\x04\x06\0\x02\x01\x12\x043\x028\x03\x1a\x10\x20Gets\x20a\
    \x20schema.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x033\x06\x0f\n\x0c\n\x05\
    \x06\0\x02\x01\x02\x12\x033\x10\x20\n\x0c\n\x05\x06\0\x02\x01\x03\x12\
    \x033+1\n\r\n\x05\x06\0\x02\x01\x04\x12\x044\x046\x06\n\x11\n\t\x06\0\
    \x02\x01\x04\xb0\xca\xbc\"\x12\x044\x046\x06\n\x0c\n\x05\x06\0\x02\x01\
    \x04\x12\x037\x042\n\x0f\n\x08\x06\0\x02\x01\x04\x9b\x08\0\x12\x037\x042\
    \n+\n\x04\x06\0\x02\x02\x12\x04;\x02@\x03\x1a\x1d\x20Lists\x20schemas\
    \x20in\x20a\x20project.\n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03;\x06\x11\
    \n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03;\x12$\n\x0c\n\x05\x06\0\x02\x02\
    \x03\x12\x03;/B\n\r\n\x05\x06\0\x02\x02\x04\x12\x04<\x04>\x06\n\x11\n\t\
    \x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x04<\x04>\x06\n\x0c\n\x05\x06\0\x02\
    \x02\x04\x12\x03?\x044\n\x0f\n\x08\x06\0\x02\x02\x04\x9b\x08\0\x12\x03?\
    \x044\n@\n\x04\x06\0\x02\x03\x12\x04C\x02I\x03\x1a2\x20Lists\x20all\x20s\
    chema\x20revisions\x20for\x20the\x20named\x20schema.\n\n\x0c\n\x05\x06\0\
    \x02\x03\x01\x12\x03C\x06\x19\n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03C\x1a\
    4\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03D\x0f*\n\r\n\x05\x06\0\x02\x03\
    \x04\x12\x04E\x04G\x06\n\x11\n\t\x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x04\
    E\x04G\x06\n\x0c\n\x05\x06\0\x02\x03\x04\x12\x03H\x042\n\x0f\n\x08\x06\0\
    \x02\x03\x04\x9b\x08\0\x12\x03H\x042\nD\n\x04\x06\0\x02\x04\x12\x04L\x02\
    R\x03\x1a6\x20Commits\x20a\x20new\x20schema\x20revision\x20to\x20an\x20e\
    xisting\x20schema.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03L\x06\x12\n\
    \x0c\n\x05\x06\0\x02\x04\x02\x12\x03L\x13&\n\x0c\n\x05\x06\0\x02\x04\x03\
    \x12\x03L17\n\r\n\x05\x06\0\x02\x04\x04\x12\x04M\x04P\x06\n\x11\n\t\x06\
    \0\x02\x04\x04\xb0\xca\xbc\"\x12\x04M\x04P\x06\n\x0c\n\x05\x06\0\x02\x04\
    \x04\x12\x03Q\x049\n\x0f\n\x08\x06\0\x02\x04\x04\x9b\x08\0\x12\x03Q\x049\
    \nY\n\x04\x06\0\x02\x05\x12\x04U\x02[\x03\x1aK\x20Creates\x20a\x20new\
    \x20schema\x20revision\x20that\x20is\x20a\x20copy\x20of\x20the\x20provid\
    ed\x20revision_id.\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03U\x06\x14\n\
    \x0c\n\x05\x06\0\x02\x05\x02\x12\x03U\x15*\n\x0c\n\x05\x06\0\x02\x05\x03\
    \x12\x03U5;\n\r\n\x05\x06\0\x02\x05\x04\x12\x04V\x04Y\x06\n\x11\n\t\x06\
    \0\x02\x05\x04\xb0\xca\xbc\"\x12\x04V\x04Y\x06\n\x0c\n\x05\x06\0\x02\x05\
    \x04\x12\x03Z\x04>\n\x0f\n\x08\x06\0\x02\x05\x04\x9b\x08\0\x12\x03Z\x04>\
    \n3\n\x04\x06\0\x02\x06\x12\x04^\x02c\x03\x1a%\x20Deletes\x20a\x20specif\
    ic\x20schema\x20revision.\n\n\x0c\n\x05\x06\0\x02\x06\x01\x12\x03^\x06\
    \x1a\n\x0c\n\x05\x06\0\x02\x06\x02\x12\x03^\x1b6\n\x0c\n\x05\x06\0\x02\
    \x06\x03\x12\x03^AG\n\r\n\x05\x06\0\x02\x06\x04\x12\x04_\x04a\x06\n\x11\
    \n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\x12\x04_\x04a\x06\n\x0c\n\x05\x06\0\
    \x02\x06\x04\x12\x03b\x04>\n\x0f\n\x08\x06\0\x02\x06\x04\x9b\x08\0\x12\
    \x03b\x04>\n!\n\x04\x06\0\x02\x07\x12\x04f\x02k\x03\x1a\x13\x20Deletes\
    \x20a\x20schema.\n\n\x0c\n\x05\x06\0\x02\x07\x01\x12\x03f\x06\x12\n\x0c\
    \n\x05\x06\0\x02\x07\x02\x12\x03f\x13&\n\x0c\n\x05\x06\0\x02\x07\x03\x12\
    \x03f1F\n\r\n\x05\x06\0\x02\x07\x04\x12\x04g\x04i\x06\n\x11\n\t\x06\0\
    \x02\x07\x04\xb0\xca\xbc\"\x12\x04g\x04i\x06\n\x0c\n\x05\x06\0\x02\x07\
    \x04\x12\x03j\x042\n\x0f\n\x08\x06\0\x02\x07\x04\x9b\x08\0\x12\x03j\x042\
    \n#\n\x04\x06\0\x02\x08\x12\x04n\x02t\x03\x1a\x15\x20Validates\x20a\x20s\
    chema.\n\n\x0c\n\x05\x06\0\x02\x08\x01\x12\x03n\x06\x14\n\x0c\n\x05\x06\
    \0\x02\x08\x02\x12\x03n\x15*\n\x0c\n\x05\x06\0\x02\x08\x03\x12\x03n5K\n\
    \r\n\x05\x06\0\x02\x08\x04\x12\x04o\x04r\x06\n\x11\n\t\x06\0\x02\x08\x04\
    \xb0\xca\xbc\"\x12\x04o\x04r\x06\n\x0c\n\x05\x06\0\x02\x08\x04\x12\x03s\
    \x04;\n\x0f\n\x08\x06\0\x02\x08\x04\x9b\x08\0\x12\x03s\x04;\n5\n\x04\x06\
    \0\x02\t\x12\x04w\x02}\x03\x1a'\x20Validates\x20a\x20message\x20against\
    \x20a\x20schema.\n\n\x0c\n\x05\x06\0\x02\t\x01\x12\x03w\x06\x15\n\x0c\n\
    \x05\x06\0\x02\t\x02\x12\x03w\x16,\n\x0c\n\x05\x06\0\x02\t\x03\x12\x03x\
    \x0f&\n\r\n\x05\x06\0\x02\t\x04\x12\x04y\x04|\x06\n\x11\n\t\x06\0\x02\t\
    \x04\xb0\xca\xbc\"\x12\x04y\x04|\x06\n\"\n\x02\x04\0\x12\x06\x81\x01\0\
    \xa8\x01\x01\x1a\x14\x20A\x20schema\x20resource.\n\n\x0b\n\x03\x04\0\x01\
    \x12\x04\x81\x01\x08\x0e\n\r\n\x03\x04\0\x07\x12\x06\x82\x01\x02\x85\x01\
    \x04\n\x0f\n\x05\x04\0\x07\x9d\x08\x12\x06\x82\x01\x02\x85\x01\x04\n3\n\
    \x04\x04\0\x04\0\x12\x06\x88\x01\x02\x91\x01\x03\x1a#\x20Possible\x20sch\
    ema\x20definition\x20types.\n\n\r\n\x05\x04\0\x04\0\x01\x12\x04\x88\x01\
    \x07\x0b\n6\n\x06\x04\0\x04\0\x02\0\x12\x04\x8a\x01\x04\x19\x1a&\x20Defa\
    ult\x20value.\x20This\x20value\x20is\x20unused.\n\n\x0f\n\x07\x04\0\x04\
    \0\x02\0\x01\x12\x04\x8a\x01\x04\x14\n\x0f\n\x07\x04\0\x04\0\x02\0\x02\
    \x12\x04\x8a\x01\x17\x18\n6\n\x06\x04\0\x04\0\x02\x01\x12\x04\x8d\x01\
    \x04\x18\x1a&\x20A\x20Protocol\x20Buffer\x20schema\x20definition.\n\n\
    \x0f\n\x07\x04\0\x04\0\x02\x01\x01\x12\x04\x8d\x01\x04\x13\n\x0f\n\x07\
    \x04\0\x04\0\x02\x01\x02\x12\x04\x8d\x01\x16\x17\n,\n\x06\x04\0\x04\0\
    \x02\x02\x12\x04\x90\x01\x04\r\x1a\x1c\x20An\x20Avro\x20schema\x20defini\
    tion.\n\n\x0f\n\x07\x04\0\x04\0\x02\x02\x01\x12\x04\x90\x01\x04\x08\n\
    \x0f\n\x07\x04\0\x04\0\x02\x02\x02\x12\x04\x90\x01\x0b\x0c\n_\n\x04\x04\
    \0\x02\0\x12\x04\x95\x01\x02;\x1aQ\x20Required.\x20Name\x20of\x20the\x20\
    schema.\n\x20Format\x20is\x20`projects/{project}/schemas/{schema}`.\n\n\
    \r\n\x05\x04\0\x02\0\x05\x12\x04\x95\x01\x02\x08\n\r\n\x05\x04\0\x02\0\
    \x01\x12\x04\x95\x01\t\r\n\r\n\x05\x04\0\x02\0\x03\x12\x04\x95\x01\x10\
    \x11\n\r\n\x05\x04\0\x02\0\x08\x12\x04\x95\x01\x12:\n\x10\n\x08\x04\0\
    \x02\0\x08\x9c\x08\0\x12\x04\x95\x01\x139\n2\n\x04\x04\0\x02\x01\x12\x04\
    \x98\x01\x02\x10\x1a$\x20The\x20type\x20of\x20the\x20schema\x20definitio\
    n.\n\n\r\n\x05\x04\0\x02\x01\x06\x12\x04\x98\x01\x02\x06\n\r\n\x05\x04\0\
    \x02\x01\x01\x12\x04\x98\x01\x07\x0b\n\r\n\x05\x04\0\x02\x01\x03\x12\x04\
    \x98\x01\x0e\x0f\n\xbf\x01\n\x04\x04\0\x02\x02\x12\x04\x9d\x01\x02\x18\
    \x1a\xb0\x01\x20The\x20definition\x20of\x20the\x20schema.\x20This\x20sho\
    uld\x20contain\x20a\x20string\x20representing\n\x20the\x20full\x20defini\
    tion\x20of\x20the\x20schema\x20that\x20is\x20a\x20valid\x20schema\x20def\
    inition\x20of\n\x20the\x20type\x20specified\x20in\x20`type`.\n\n\r\n\x05\
    \x04\0\x02\x02\x05\x12\x04\x9d\x01\x02\x08\n\r\n\x05\x04\0\x02\x02\x01\
    \x12\x04\x9d\x01\t\x13\n\r\n\x05\x04\0\x02\x02\x03\x12\x04\x9d\x01\x16\
    \x17\nH\n\x04\x04\0\x02\x03\x12\x06\xa0\x01\x02\xa3\x01\x04\x1a8\x20Outp\
    ut\x20only.\x20Immutable.\x20The\x20revision\x20ID\x20of\x20the\x20schem\
    a.\n\n\r\n\x05\x04\0\x02\x03\x05\x12\x04\xa0\x01\x02\x08\n\r\n\x05\x04\0\
    \x02\x03\x01\x12\x04\xa0\x01\t\x14\n\r\n\x05\x04\0\x02\x03\x03\x12\x04\
    \xa0\x01\x17\x18\n\x0f\n\x05\x04\0\x02\x03\x08\x12\x06\xa0\x01\x19\xa3\
    \x01\x03\n\x10\n\x08\x04\0\x02\x03\x08\x9c\x08\0\x12\x04\xa1\x01\x04+\n\
    \x10\n\x08\x04\0\x02\x03\x08\x9c\x08\x01\x12\x04\xa2\x01\x04-\nK\n\x04\
    \x04\0\x02\x04\x12\x06\xa6\x01\x02\xa7\x012\x1a;\x20Output\x20only.\x20T\
    he\x20timestamp\x20that\x20the\x20revision\x20was\x20created.\n\n\r\n\
    \x05\x04\0\x02\x04\x06\x12\x04\xa6\x01\x02\x1b\n\r\n\x05\x04\0\x02\x04\
    \x01\x12\x04\xa6\x01\x1c0\n\r\n\x05\x04\0\x02\x04\x03\x12\x04\xa6\x0134\
    \n\r\n\x05\x04\0\x02\x04\x08\x12\x04\xa7\x01\x061\n\x10\n\x08\x04\0\x02\
    \x04\x08\x9c\x08\0\x12\x04\xa7\x01\x070\nY\n\x02\x05\0\x12\x06\xab\x01\0\
    \xb5\x01\x01\x1aK\x20View\x20of\x20Schema\x20object\x20fields\x20to\x20b\
    e\x20returned\x20by\x20GetSchema\x20and\x20ListSchemas.\n\n\x0b\n\x03\
    \x05\0\x01\x12\x04\xab\x01\x05\x0f\nS\n\x04\x05\0\x02\0\x12\x04\xae\x01\
    \x02\x1e\x1aE\x20The\x20default\x20/\x20unset\x20value.\n\x20The\x20API\
    \x20will\x20default\x20to\x20the\x20BASIC\x20view.\n\n\r\n\x05\x05\0\x02\
    \0\x01\x12\x04\xae\x01\x02\x19\n\r\n\x05\x05\0\x02\0\x02\x12\x04\xae\x01\
    \x1c\x1d\nP\n\x04\x05\0\x02\x01\x12\x04\xb1\x01\x02\x0c\x1aB\x20Include\
    \x20the\x20name\x20and\x20type\x20of\x20the\x20schema,\x20but\x20not\x20\
    the\x20definition.\n\n\r\n\x05\x05\0\x02\x01\x01\x12\x04\xb1\x01\x02\x07\
    \n\r\n\x05\x05\0\x02\x01\x02\x12\x04\xb1\x01\n\x0b\n1\n\x04\x05\0\x02\
    \x02\x12\x04\xb4\x01\x02\x0b\x1a#\x20Include\x20all\x20Schema\x20object\
    \x20fields.\n\n\r\n\x05\x05\0\x02\x02\x01\x12\x04\xb4\x01\x02\x06\n\r\n\
    \x05\x05\0\x02\x02\x02\x12\x04\xb4\x01\t\n\n4\n\x02\x04\x01\x12\x06\xb8\
    \x01\0\xcf\x01\x01\x1a&\x20Request\x20for\x20the\x20CreateSchema\x20meth\
    od.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\xb8\x01\x08\x1b\nv\n\x04\x04\x01\
    \x02\0\x12\x06\xbb\x01\x02\xc0\x01\x04\x1af\x20Required.\x20The\x20name\
    \x20of\x20the\x20project\x20in\x20which\x20to\x20create\x20the\x20schema\
    .\n\x20Format\x20is\x20`projects/{project-id}`.\n\n\r\n\x05\x04\x01\x02\
    \0\x05\x12\x04\xbb\x01\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xbb\
    \x01\t\x0f\n\r\n\x05\x04\x01\x02\0\x03\x12\x04\xbb\x01\x12\x13\n\x0f\n\
    \x05\x04\x01\x02\0\x08\x12\x06\xbb\x01\x14\xc0\x01\x03\n\x10\n\x08\x04\
    \x01\x02\0\x08\x9c\x08\0\x12\x04\xbc\x01\x04*\n\x11\n\x07\x04\x01\x02\0\
    \x08\x9f\x08\x12\x06\xbd\x01\x04\xbf\x01\x05\n\xd3\x01\n\x04\x04\x01\x02\
    \x01\x12\x04\xc7\x01\x02=\x1a\xc4\x01\x20Required.\x20The\x20schema\x20o\
    bject\x20to\x20create.\n\n\x20This\x20schema's\x20`name`\x20parameter\
    \x20is\x20ignored.\x20The\x20schema\x20object\x20returned\n\x20by\x20Cre\
    ateSchema\x20will\x20have\x20a\x20`name`\x20made\x20using\x20the\x20give\
    n\x20`parent`\x20and\n\x20`schema_id`.\n\n\r\n\x05\x04\x01\x02\x01\x06\
    \x12\x04\xc7\x01\x02\x08\n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\xc7\x01\t\
    \x0f\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\xc7\x01\x12\x13\n\r\n\x05\x04\
    \x01\x02\x01\x08\x12\x04\xc7\x01\x14<\n\x10\n\x08\x04\x01\x02\x01\x08\
    \x9c\x08\0\x12\x04\xc7\x01\x15;\n\xd4\x01\n\x04\x04\x01\x02\x02\x12\x04\
    \xce\x01\x02\x17\x1a\xc5\x01\x20The\x20ID\x20to\x20use\x20for\x20the\x20\
    schema,\x20which\x20will\x20become\x20the\x20final\x20component\x20of\n\
    \x20the\x20schema's\x20resource\x20name.\n\n\x20See\x20https://cloud.goo\
    gle.com/pubsub/docs/admin#resource_names\x20for\x20resource\n\x20name\
    \x20constraints.\n\n\r\n\x05\x04\x01\x02\x02\x05\x12\x04\xce\x01\x02\x08\
    \n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\xce\x01\t\x12\n\r\n\x05\x04\x01\
    \x02\x02\x03\x12\x04\xce\x01\x15\x16\n1\n\x02\x04\x02\x12\x06\xd2\x01\0\
    \xdd\x01\x01\x1a#\x20Request\x20for\x20the\x20GetSchema\x20method.\n\n\
    \x0b\n\x03\x04\x02\x01\x12\x04\xd2\x01\x08\x18\nl\n\x04\x04\x02\x02\0\
    \x12\x06\xd5\x01\x02\xd8\x01\x04\x1a\\\x20Required.\x20The\x20name\x20of\
    \x20the\x20schema\x20to\x20get.\n\x20Format\x20is\x20`projects/{project}\
    /schemas/{schema}`.\n\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\xd5\x01\x02\
    \x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xd5\x01\t\r\n\r\n\x05\x04\x02\
    \x02\0\x03\x12\x04\xd5\x01\x10\x11\n\x0f\n\x05\x04\x02\x02\0\x08\x12\x06\
    \xd5\x01\x12\xd8\x01\x03\n\x10\n\x08\x04\x02\x02\0\x08\x9c\x08\0\x12\x04\
    \xd6\x01\x04*\n\x0f\n\x07\x04\x02\x02\0\x08\x9f\x08\x12\x04\xd7\x01\x04N\
    \n\xa0\x01\n\x04\x04\x02\x02\x01\x12\x04\xdc\x01\x02\x16\x1a\x91\x01\x20\
    The\x20set\x20of\x20fields\x20to\x20return\x20in\x20the\x20response.\x20\
    If\x20not\x20set,\x20returns\x20a\x20Schema\n\x20with\x20all\x20fields\
    \x20filled\x20out.\x20Set\x20to\x20`BASIC`\x20to\x20omit\x20the\x20`defi\
    nition`.\n\n\r\n\x05\x04\x02\x02\x01\x06\x12\x04\xdc\x01\x02\x0c\n\r\n\
    \x05\x04\x02\x02\x01\x01\x12\x04\xdc\x01\r\x11\n\r\n\x05\x04\x02\x02\x01\
    \x03\x12\x04\xdc\x01\x14\x15\n5\n\x02\x04\x03\x12\x06\xe0\x01\0\xf6\x01\
    \x01\x1a'\x20Request\x20for\x20the\x20`ListSchemas`\x20method.\n\n\x0b\n\
    \x03\x04\x03\x01\x12\x04\xe0\x01\x08\x1a\nq\n\x04\x04\x03\x02\0\x12\x06\
    \xe3\x01\x02\xe8\x01\x04\x1aa\x20Required.\x20The\x20name\x20of\x20the\
    \x20project\x20in\x20which\x20to\x20list\x20schemas.\n\x20Format\x20is\
    \x20`projects/{project-id}`.\n\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\xe3\
    \x01\x02\x08\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\xe3\x01\t\x0f\n\r\n\x05\
    \x04\x03\x02\0\x03\x12\x04\xe3\x01\x12\x13\n\x0f\n\x05\x04\x03\x02\0\x08\
    \x12\x06\xe3\x01\x14\xe8\x01\x03\n\x10\n\x08\x04\x03\x02\0\x08\x9c\x08\0\
    \x12\x04\xe4\x01\x04*\n\x11\n\x07\x04\x03\x02\0\x08\x9f\x08\x12\x06\xe5\
    \x01\x04\xe7\x01\x05\n\xb6\x01\n\x04\x04\x03\x02\x01\x12\x04\xed\x01\x02\
    \x16\x1a\xa7\x01\x20The\x20set\x20of\x20Schema\x20fields\x20to\x20return\
    \x20in\x20the\x20response.\x20If\x20not\x20set,\x20returns\n\x20Schemas\
    \x20with\x20`name`\x20and\x20`type`,\x20but\x20not\x20`definition`.\x20S\
    et\x20to\x20`FULL`\x20to\n\x20retrieve\x20all\x20fields.\n\n\r\n\x05\x04\
    \x03\x02\x01\x06\x12\x04\xed\x01\x02\x0c\n\r\n\x05\x04\x03\x02\x01\x01\
    \x12\x04\xed\x01\r\x11\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\xed\x01\x14\
    \x15\n4\n\x04\x04\x03\x02\x02\x12\x04\xf0\x01\x02\x16\x1a&\x20Maximum\
    \x20number\x20of\x20schemas\x20to\x20return.\n\n\r\n\x05\x04\x03\x02\x02\
    \x05\x12\x04\xf0\x01\x02\x07\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xf0\
    \x01\x08\x11\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\xf0\x01\x14\x15\n\xc6\
    \x01\n\x04\x04\x03\x02\x03\x12\x04\xf5\x01\x02\x18\x1a\xb7\x01\x20The\
    \x20value\x20returned\x20by\x20the\x20last\x20`ListSchemasResponse`;\x20\
    indicates\x20that\n\x20this\x20is\x20a\x20continuation\x20of\x20a\x20pri\
    or\x20`ListSchemas`\x20call,\x20and\x20that\x20the\n\x20system\x20should\
    \x20return\x20the\x20next\x20page\x20of\x20data.\n\n\r\n\x05\x04\x03\x02\
    \x03\x05\x12\x04\xf5\x01\x02\x08\n\r\n\x05\x04\x03\x02\x03\x01\x12\x04\
    \xf5\x01\t\x13\n\r\n\x05\x04\x03\x02\x03\x03\x12\x04\xf5\x01\x16\x17\n6\
    \n\x02\x04\x04\x12\x06\xf9\x01\0\x80\x02\x01\x1a(\x20Response\x20for\x20\
    the\x20`ListSchemas`\x20method.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\xf9\
    \x01\x08\x1b\n&\n\x04\x04\x04\x02\0\x12\x04\xfb\x01\x02\x1e\x1a\x18\x20T\
    he\x20resulting\x20schemas.\n\n\r\n\x05\x04\x04\x02\0\x04\x12\x04\xfb\
    \x01\x02\n\n\r\n\x05\x04\x04\x02\0\x06\x12\x04\xfb\x01\x0b\x11\n\r\n\x05\
    \x04\x04\x02\0\x01\x12\x04\xfb\x01\x12\x19\n\r\n\x05\x04\x04\x02\0\x03\
    \x12\x04\xfb\x01\x1c\x1d\n\x9b\x01\n\x04\x04\x04\x02\x01\x12\x04\xff\x01\
    \x02\x1d\x1a\x8c\x01\x20If\x20not\x20empty,\x20indicates\x20that\x20ther\
    e\x20may\x20be\x20more\x20schemas\x20that\x20match\x20the\n\x20request;\
    \x20this\x20value\x20should\x20be\x20passed\x20in\x20a\x20new\x20`ListSc\
    hemasRequest`.\n\n\r\n\x05\x04\x04\x02\x01\x05\x12\x04\xff\x01\x02\x08\n\
    \r\n\x05\x04\x04\x02\x01\x01\x12\x04\xff\x01\t\x18\n\r\n\x05\x04\x04\x02\
    \x01\x03\x12\x04\xff\x01\x1b\x1c\n=\n\x02\x04\x05\x12\x06\x83\x02\0\x95\
    \x02\x01\x1a/\x20Request\x20for\x20the\x20`ListSchemaRevisions`\x20metho\
    d.\n\n\x0b\n\x03\x04\x05\x01\x12\x04\x83\x02\x08\"\nI\n\x04\x04\x05\x02\
    \0\x12\x06\x85\x02\x02\x88\x02\x04\x1a9\x20Required.\x20The\x20name\x20o\
    f\x20the\x20schema\x20to\x20list\x20revisions\x20for.\n\n\r\n\x05\x04\
    \x05\x02\0\x05\x12\x04\x85\x02\x02\x08\n\r\n\x05\x04\x05\x02\0\x01\x12\
    \x04\x85\x02\t\r\n\r\n\x05\x04\x05\x02\0\x03\x12\x04\x85\x02\x10\x11\n\
    \x0f\n\x05\x04\x05\x02\0\x08\x12\x06\x85\x02\x12\x88\x02\x03\n\x10\n\x08\
    \x04\x05\x02\0\x08\x9c\x08\0\x12\x04\x86\x02\x04*\n\x0f\n\x07\x04\x05\
    \x02\0\x08\x9f\x08\x12\x04\x87\x02\x04N\n\xb6\x01\n\x04\x04\x05\x02\x01\
    \x12\x04\x8d\x02\x02\x16\x1a\xa7\x01\x20The\x20set\x20of\x20Schema\x20fi\
    elds\x20to\x20return\x20in\x20the\x20response.\x20If\x20not\x20set,\x20r\
    eturns\n\x20Schemas\x20with\x20`name`\x20and\x20`type`,\x20but\x20not\
    \x20`definition`.\x20Set\x20to\x20`FULL`\x20to\n\x20retrieve\x20all\x20f\
    ields.\n\n\r\n\x05\x04\x05\x02\x01\x06\x12\x04\x8d\x02\x02\x0c\n\r\n\x05\
    \x04\x05\x02\x01\x01\x12\x04\x8d\x02\r\x11\n\r\n\x05\x04\x05\x02\x01\x03\
    \x12\x04\x8d\x02\x14\x15\nC\n\x04\x04\x05\x02\x02\x12\x04\x90\x02\x02\
    \x16\x1a5\x20The\x20maximum\x20number\x20of\x20revisions\x20to\x20return\
    \x20per\x20page.\n\n\r\n\x05\x04\x05\x02\x02\x05\x12\x04\x90\x02\x02\x07\
    \n\r\n\x05\x04\x05\x02\x02\x01\x12\x04\x90\x02\x08\x11\n\r\n\x05\x04\x05\
    \x02\x02\x03\x12\x04\x90\x02\x14\x15\n\x81\x01\n\x04\x04\x05\x02\x03\x12\
    \x04\x94\x02\x02\x18\x1as\x20The\x20page\x20token,\x20received\x20from\
    \x20a\x20previous\x20ListSchemaRevisions\x20call.\n\x20Provide\x20this\
    \x20to\x20retrieve\x20the\x20subsequent\x20page.\n\n\r\n\x05\x04\x05\x02\
    \x03\x05\x12\x04\x94\x02\x02\x08\n\r\n\x05\x04\x05\x02\x03\x01\x12\x04\
    \x94\x02\t\x13\n\r\n\x05\x04\x05\x02\x03\x03\x12\x04\x94\x02\x16\x17\n>\
    \n\x02\x04\x06\x12\x06\x98\x02\0\x9f\x02\x01\x1a0\x20Response\x20for\x20\
    the\x20`ListSchemaRevisions`\x20method.\n\n\x0b\n\x03\x04\x06\x01\x12\
    \x04\x98\x02\x08#\n,\n\x04\x04\x06\x02\0\x12\x04\x9a\x02\x02\x1e\x1a\x1e\
    \x20The\x20revisions\x20of\x20the\x20schema.\n\n\r\n\x05\x04\x06\x02\0\
    \x04\x12\x04\x9a\x02\x02\n\n\r\n\x05\x04\x06\x02\0\x06\x12\x04\x9a\x02\
    \x0b\x11\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\x9a\x02\x12\x19\n\r\n\x05\
    \x04\x06\x02\0\x03\x12\x04\x9a\x02\x1c\x1d\n\x8b\x01\n\x04\x04\x06\x02\
    \x01\x12\x04\x9e\x02\x02\x1d\x1a}\x20A\x20token\x20that\x20can\x20be\x20\
    sent\x20as\x20`page_token`\x20to\x20retrieve\x20the\x20next\x20page.\n\
    \x20If\x20this\x20field\x20is\x20empty,\x20there\x20are\x20no\x20subsequ\
    ent\x20pages.\n\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\x9e\x02\x02\x08\n\
    \r\n\x05\x04\x06\x02\x01\x01\x12\x04\x9e\x02\t\x18\n\r\n\x05\x04\x06\x02\
    \x01\x03\x12\x04\x9e\x02\x1b\x1c\n0\n\x02\x04\x07\x12\x06\xa2\x02\0\xac\
    \x02\x01\x1a\"\x20Request\x20for\x20CommitSchema\x20method.\n\n\x0b\n\
    \x03\x04\x07\x01\x12\x04\xa2\x02\x08\x1b\nu\n\x04\x04\x07\x02\0\x12\x06\
    \xa5\x02\x02\xa8\x02\x04\x1ae\x20Required.\x20The\x20name\x20of\x20the\
    \x20schema\x20we\x20are\x20revising.\n\x20Format\x20is\x20`projects/{pro\
    ject}/schemas/{schema}`.\n\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\xa5\x02\
    \x02\x08\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xa5\x02\t\r\n\r\n\x05\x04\
    \x07\x02\0\x03\x12\x04\xa5\x02\x10\x11\n\x0f\n\x05\x04\x07\x02\0\x08\x12\
    \x06\xa5\x02\x12\xa8\x02\x03\n\x10\n\x08\x04\x07\x02\0\x08\x9c\x08\0\x12\
    \x04\xa6\x02\x04*\n\x0f\n\x07\x04\x07\x02\0\x08\x9f\x08\x12\x04\xa7\x02\
    \x04N\n8\n\x04\x04\x07\x02\x01\x12\x04\xab\x02\x02=\x1a*\x20Required.\
    \x20The\x20schema\x20revision\x20to\x20commit.\n\n\r\n\x05\x04\x07\x02\
    \x01\x06\x12\x04\xab\x02\x02\x08\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\
    \xab\x02\t\x0f\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\xab\x02\x12\x13\n\r\
    \n\x05\x04\x07\x02\x01\x08\x12\x04\xab\x02\x14<\n\x10\n\x08\x04\x07\x02\
    \x01\x08\x9c\x08\0\x12\x04\xab\x02\x15;\n8\n\x02\x04\x08\x12\x06\xaf\x02\
    \0\xbb\x02\x01\x1a*\x20Request\x20for\x20the\x20`RollbackSchema`\x20meth\
    od.\n\n\x0b\n\x03\x04\x08\x01\x12\x04\xaf\x02\x08\x1d\nJ\n\x04\x04\x08\
    \x02\0\x12\x06\xb1\x02\x02\xb4\x02\x04\x1a:\x20Required.\x20The\x20schem\
    a\x20being\x20rolled\x20back\x20with\x20revision\x20id.\n\n\r\n\x05\x04\
    \x08\x02\0\x05\x12\x04\xb1\x02\x02\x08\n\r\n\x05\x04\x08\x02\0\x01\x12\
    \x04\xb1\x02\t\r\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xb1\x02\x10\x11\n\
    \x0f\n\x05\x04\x08\x02\0\x08\x12\x06\xb1\x02\x12\xb4\x02\x03\n\x10\n\x08\
    \x04\x08\x02\0\x08\x9c\x08\0\x12\x04\xb2\x02\x04*\n\x0f\n\x07\x04\x08\
    \x02\0\x08\x9f\x08\x12\x04\xb3\x02\x04N\n{\n\x04\x04\x08\x02\x01\x12\x04\
    \xba\x02\x02B\x1am\x20Required.\x20The\x20revision\x20ID\x20to\x20roll\
    \x20back\x20to.\n\x20It\x20must\x20be\x20a\x20revision\x20of\x20the\x20s\
    ame\x20schema.\n\n\x20\x20\x20Example:\x20c7cfa2a8\n\n\r\n\x05\x04\x08\
    \x02\x01\x05\x12\x04\xba\x02\x02\x08\n\r\n\x05\x04\x08\x02\x01\x01\x12\
    \x04\xba\x02\t\x14\n\r\n\x05\x04\x08\x02\x01\x03\x12\x04\xba\x02\x17\x18\
    \n\r\n\x05\x04\x08\x02\x01\x08\x12\x04\xba\x02\x19A\n\x10\n\x08\x04\x08\
    \x02\x01\x08\x9c\x08\0\x12\x04\xba\x02\x1a@\n>\n\x02\x04\t\x12\x06\xbe\
    \x02\0\xcd\x02\x01\x1a0\x20Request\x20for\x20the\x20`DeleteSchemaRevisio\
    n`\x20method.\n\n\x0b\n\x03\x04\t\x01\x12\x04\xbe\x02\x08#\n\xa9\x01\n\
    \x04\x04\t\x02\0\x12\x06\xc3\x02\x02\xc6\x02\x04\x1a\x98\x01\x20Required\
    .\x20The\x20name\x20of\x20the\x20schema\x20revision\x20to\x20be\x20delet\
    ed,\x20with\x20a\x20revision\x20ID\n\x20explicitly\x20included.\n\n\x20E\
    xample:\x20`projects/123/schemas/my-schema@c7cfa2a8`\n\n\r\n\x05\x04\t\
    \x02\0\x05\x12\x04\xc3\x02\x02\x08\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xc3\
    \x02\t\r\n\r\n\x05\x04\t\x02\0\x03\x12\x04\xc3\x02\x10\x11\n\x0f\n\x05\
    \x04\t\x02\0\x08\x12\x06\xc3\x02\x12\xc6\x02\x03\n\x10\n\x08\x04\t\x02\0\
    \x08\x9c\x08\0\x12\x04\xc4\x02\x04*\n\x0f\n\x07\x04\t\x02\0\x08\x9f\x08\
    \x12\x04\xc5\x02\x04N\n\xac\x01\n\x04\x04\t\x02\x01\x12\x06\xcb\x02\x02\
    \xcc\x02B\x1a\x9b\x01\x20Optional.\x20This\x20field\x20is\x20deprecated\
    \x20and\x20should\x20not\x20be\x20used\x20for\x20specifying\n\x20the\x20\
    revision\x20ID.\x20The\x20revision\x20ID\x20should\x20be\x20specified\
    \x20via\x20the\x20`name`\n\x20parameter.\n\n\r\n\x05\x04\t\x02\x01\x05\
    \x12\x04\xcb\x02\x02\x08\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\xcb\x02\t\
    \x14\n\r\n\x05\x04\t\x02\x01\x03\x12\x04\xcb\x02\x17\x18\n\r\n\x05\x04\t\
    \x02\x01\x08\x12\x04\xcc\x02\x06A\n\x0e\n\x06\x04\t\x02\x01\x08\x03\x12\
    \x04\xcc\x02\x07\x18\n\x10\n\x08\x04\t\x02\x01\x08\x9c\x08\0\x12\x04\xcc\
    \x02\x1a@\n6\n\x02\x04\n\x12\x06\xd0\x02\0\xd7\x02\x01\x1a(\x20Request\
    \x20for\x20the\x20`DeleteSchema`\x20method.\n\n\x0b\n\x03\x04\n\x01\x12\
    \x04\xd0\x02\x08\x1b\nk\n\x04\x04\n\x02\0\x12\x06\xd3\x02\x02\xd6\x02\
    \x04\x1a[\x20Required.\x20Name\x20of\x20the\x20schema\x20to\x20delete.\n\
    \x20Format\x20is\x20`projects/{project}/schemas/{schema}`.\n\n\r\n\x05\
    \x04\n\x02\0\x05\x12\x04\xd3\x02\x02\x08\n\r\n\x05\x04\n\x02\0\x01\x12\
    \x04\xd3\x02\t\r\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xd3\x02\x10\x11\n\x0f\
    \n\x05\x04\n\x02\0\x08\x12\x06\xd3\x02\x12\xd6\x02\x03\n\x10\n\x08\x04\n\
    \x02\0\x08\x9c\x08\0\x12\x04\xd4\x02\x04*\n\x0f\n\x07\x04\n\x02\0\x08\
    \x9f\x08\x12\x04\xd5\x02\x04N\n8\n\x02\x04\x0b\x12\x06\xda\x02\0\xe6\x02\
    \x01\x1a*\x20Request\x20for\x20the\x20`ValidateSchema`\x20method.\n\n\
    \x0b\n\x03\x04\x0b\x01\x12\x04\xda\x02\x08\x1d\nu\n\x04\x04\x0b\x02\0\
    \x12\x06\xdd\x02\x02\xe2\x02\x04\x1ae\x20Required.\x20The\x20name\x20of\
    \x20the\x20project\x20in\x20which\x20to\x20validate\x20schemas.\n\x20For\
    mat\x20is\x20`projects/{project-id}`.\n\n\r\n\x05\x04\x0b\x02\0\x05\x12\
    \x04\xdd\x02\x02\x08\n\r\n\x05\x04\x0b\x02\0\x01\x12\x04\xdd\x02\t\x0f\n\
    \r\n\x05\x04\x0b\x02\0\x03\x12\x04\xdd\x02\x12\x13\n\x0f\n\x05\x04\x0b\
    \x02\0\x08\x12\x06\xdd\x02\x14\xe2\x02\x03\n\x10\n\x08\x04\x0b\x02\0\x08\
    \x9c\x08\0\x12\x04\xde\x02\x04*\n\x11\n\x07\x04\x0b\x02\0\x08\x9f\x08\
    \x12\x06\xdf\x02\x04\xe1\x02\x05\n8\n\x04\x04\x0b\x02\x01\x12\x04\xe5\
    \x02\x02=\x1a*\x20Required.\x20The\x20schema\x20object\x20to\x20validate\
    .\n\n\r\n\x05\x04\x0b\x02\x01\x06\x12\x04\xe5\x02\x02\x08\n\r\n\x05\x04\
    \x0b\x02\x01\x01\x12\x04\xe5\x02\t\x0f\n\r\n\x05\x04\x0b\x02\x01\x03\x12\
    \x04\xe5\x02\x12\x13\n\r\n\x05\x04\x0b\x02\x01\x08\x12\x04\xe5\x02\x14<\
    \n\x10\n\x08\x04\x0b\x02\x01\x08\x9c\x08\0\x12\x04\xe5\x02\x15;\nG\n\x02\
    \x04\x0c\x12\x04\xea\x02\0!\x1a;\x20Response\x20for\x20the\x20`ValidateS\
    chema`\x20method.\n\x20Empty\x20for\x20now.\n\n\x0b\n\x03\x04\x0c\x01\
    \x12\x04\xea\x02\x08\x1e\n9\n\x02\x04\r\x12\x06\xed\x02\0\x88\x03\x01\
    \x1a+\x20Request\x20for\x20the\x20`ValidateMessage`\x20method.\n\n\x0b\n\
    \x03\x04\r\x01\x12\x04\xed\x02\x08\x1e\nu\n\x04\x04\r\x02\0\x12\x06\xf0\
    \x02\x02\xf5\x02\x04\x1ae\x20Required.\x20The\x20name\x20of\x20the\x20pr\
    oject\x20in\x20which\x20to\x20validate\x20schemas.\n\x20Format\x20is\x20\
    `projects/{project-id}`.\n\n\r\n\x05\x04\r\x02\0\x05\x12\x04\xf0\x02\x02\
    \x08\n\r\n\x05\x04\r\x02\0\x01\x12\x04\xf0\x02\t\x0f\n\r\n\x05\x04\r\x02\
    \0\x03\x12\x04\xf0\x02\x12\x13\n\x0f\n\x05\x04\r\x02\0\x08\x12\x06\xf0\
    \x02\x14\xf5\x02\x03\n\x10\n\x08\x04\r\x02\0\x08\x9c\x08\0\x12\x04\xf1\
    \x02\x04*\n\x11\n\x07\x04\r\x02\0\x08\x9f\x08\x12\x06\xf2\x02\x04\xf4\
    \x02\x05\n\x0e\n\x04\x04\r\x08\0\x12\x06\xf7\x02\x02\x81\x03\x03\n\r\n\
    \x05\x04\r\x08\0\x01\x12\x04\xf7\x02\x08\x13\nr\n\x04\x04\r\x02\x01\x12\
    \x06\xfb\x02\x04\xfd\x02\x06\x1ab\x20Name\x20of\x20the\x20schema\x20agai\
    nst\x20which\x20to\x20validate.\n\n\x20Format\x20is\x20`projects/{projec\
    t}/schemas/{schema}`.\n\n\r\n\x05\x04\r\x02\x01\x05\x12\x04\xfb\x02\x04\
    \n\n\r\n\x05\x04\r\x02\x01\x01\x12\x04\xfb\x02\x0b\x0f\n\r\n\x05\x04\r\
    \x02\x01\x03\x12\x04\xfb\x02\x12\x13\n\x0f\n\x05\x04\r\x02\x01\x08\x12\
    \x06\xfb\x02\x14\xfd\x02\x05\n\x0f\n\x07\x04\r\x02\x01\x08\x9f\x08\x12\
    \x04\xfc\x02\x06P\n7\n\x04\x04\r\x02\x02\x12\x04\x80\x03\x04\x16\x1a)\
    \x20Ad-hoc\x20schema\x20against\x20which\x20to\x20validate\n\n\r\n\x05\
    \x04\r\x02\x02\x06\x12\x04\x80\x03\x04\n\n\r\n\x05\x04\r\x02\x02\x01\x12\
    \x04\x80\x03\x0b\x11\n\r\n\x05\x04\r\x02\x02\x03\x12\x04\x80\x03\x14\x15\
    \nG\n\x04\x04\r\x02\x03\x12\x04\x84\x03\x02\x14\x1a9\x20Message\x20to\
    \x20validate\x20against\x20the\x20provided\x20`schema_spec`.\n\n\r\n\x05\
    \x04\r\x02\x03\x05\x12\x04\x84\x03\x02\x07\n\r\n\x05\x04\r\x02\x03\x01\
    \x12\x04\x84\x03\x08\x0f\n\r\n\x05\x04\r\x02\x03\x03\x12\x04\x84\x03\x12\
    \x13\n2\n\x04\x04\r\x02\x04\x12\x04\x87\x03\x02\x18\x1a$\x20The\x20encod\
    ing\x20expected\x20for\x20messages\n\n\r\n\x05\x04\r\x02\x04\x06\x12\x04\
    \x87\x03\x02\n\n\r\n\x05\x04\r\x02\x04\x01\x12\x04\x87\x03\x0b\x13\n\r\n\
    \x05\x04\r\x02\x04\x03\x12\x04\x87\x03\x16\x17\nH\n\x02\x04\x0e\x12\x04\
    \x8c\x03\0\"\x1a<\x20Response\x20for\x20the\x20`ValidateMessage`\x20meth\
    od.\n\x20Empty\x20for\x20now.\n\n\x0b\n\x03\x04\x0e\x01\x12\x04\x8c\x03\
    \x08\x1f\n5\n\x02\x05\x01\x12\x06\x8f\x03\0\x99\x03\x01\x1a'\x20Possible\
    \x20encoding\x20types\x20for\x20messages.\n\n\x0b\n\x03\x05\x01\x01\x12\
    \x04\x8f\x03\x05\r\n\x1b\n\x04\x05\x01\x02\0\x12\x04\x91\x03\x02\x1b\x1a\
    \r\x20Unspecified\n\n\r\n\x05\x05\x01\x02\0\x01\x12\x04\x91\x03\x02\x16\
    \n\r\n\x05\x05\x01\x02\0\x02\x12\x04\x91\x03\x19\x1a\n\x1d\n\x04\x05\x01\
    \x02\x01\x12\x04\x94\x03\x02\x0b\x1a\x0f\x20JSON\x20encoding\n\n\r\n\x05\
    \x05\x01\x02\x01\x01\x12\x04\x94\x03\x02\x06\n\r\n\x05\x05\x01\x02\x01\
    \x02\x12\x04\x94\x03\t\n\n}\n\x04\x05\x01\x02\x02\x12\x04\x98\x03\x02\r\
    \x1ao\x20Binary\x20encoding,\x20as\x20defined\x20by\x20the\x20schema\x20\
    type.\x20For\x20some\x20schema\x20types,\n\x20binary\x20encoding\x20may\
    \x20not\x20be\x20available.\n\n\r\n\x05\x05\x01\x02\x02\x01\x12\x04\x98\
    \x03\x02\x08\n\r\n\x05\x05\x01\x02\x02\x02\x12\x04\x98\x03\x0b\x0cb\x06p\
    roto3\
";

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