beam-proto-rs 2.41.0

// This file is generated by rust-protobuf 3.1.0. Do not edit
// .proto file is parsed by protoc 3.21.5
// @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_results)]
#![allow(unused_mut)]

//! Generated file from `org/apache/beam/model/pipeline/v1/schema.proto`

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.Schema)
pub struct Schema {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Schema.fields)
    pub fields: ::std::vec::Vec<Field>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Schema.id)
    pub id: ::std::string::String,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Schema.options)
    pub options: ::std::vec::Vec<Option>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Schema.encoding_positions_set)
    pub encoding_positions_set: bool,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.Schema.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(4);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "fields",
            |m: &Schema| { &m.fields },
            |m: &mut Schema| { &mut m.fields },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "id",
            |m: &Schema| { &m.id },
            |m: &mut Schema| { &mut m.id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "options",
            |m: &Schema| { &m.options },
            |m: &mut Schema| { &mut m.options },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "encoding_positions_set",
            |m: &Schema| { &m.encoding_positions_set },
            |m: &mut Schema| { &mut m.encoding_positions_set },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Schema>(
            "Schema",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Schema {
    const NAME: &'static str = "Schema";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.fields.push(is.read_message()?);
                },
                18 => {
                    self.id = is.read_string()?;
                },
                26 => {
                    self.options.push(is.read_message()?);
                },
                32 => {
                    self.encoding_positions_set = is.read_bool()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.fields {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if !self.id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.id);
        }
        for value in &self.options {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.encoding_positions_set != false {
            my_size += 1 + 1;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.fields {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if !self.id.is_empty() {
            os.write_string(2, &self.id)?;
        }
        for v in &self.options {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if self.encoding_positions_set != false {
            os.write_bool(4, self.encoding_positions_set)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.fields.clear();
        self.id.clear();
        self.options.clear();
        self.encoding_positions_set = false;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Schema {
        static instance: Schema = Schema {
            fields: ::std::vec::Vec::new(),
            id: ::std::string::String::new(),
            options: ::std::vec::Vec::new(),
            encoding_positions_set: false,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Schema {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Schema").unwrap()).clone()
    }
}

impl ::std::fmt::Display 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 {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.Field)
pub struct Field {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Field.name)
    pub name: ::std::string::String,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Field.description)
    pub description: ::std::string::String,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Field.type)
    pub type_: ::protobuf::MessageField<FieldType>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Field.id)
    pub id: i32,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Field.encoding_position)
    pub encoding_position: i32,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Field.options)
    pub options: ::std::vec::Vec<Option>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.Field.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(6);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "name",
            |m: &Field| { &m.name },
            |m: &mut Field| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "description",
            |m: &Field| { &m.description },
            |m: &mut Field| { &mut m.description },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldType>(
            "type",
            |m: &Field| { &m.type_ },
            |m: &mut Field| { &mut m.type_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "id",
            |m: &Field| { &m.id },
            |m: &mut Field| { &mut m.id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "encoding_position",
            |m: &Field| { &m.encoding_position },
            |m: &mut Field| { &mut m.encoding_position },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "options",
            |m: &Field| { &m.options },
            |m: &mut Field| { &mut m.options },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Field>(
            "Field",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Field {
    const NAME: &'static str = "Field";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = is.read_string()?;
                },
                18 => {
                    self.description = is.read_string()?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.type_)?;
                },
                32 => {
                    self.id = is.read_int32()?;
                },
                40 => {
                    self.encoding_position = is.read_int32()?;
                },
                50 => {
                    self.options.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if !self.description.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.description);
        }
        if let Some(v) = self.type_.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.id != 0 {
            my_size += ::protobuf::rt::int32_size(4, self.id);
        }
        if self.encoding_position != 0 {
            my_size += ::protobuf::rt::int32_size(5, self.encoding_position);
        }
        for value in &self.options {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if !self.description.is_empty() {
            os.write_string(2, &self.description)?;
        }
        if let Some(v) = self.type_.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if self.id != 0 {
            os.write_int32(4, self.id)?;
        }
        if self.encoding_position != 0 {
            os.write_int32(5, self.encoding_position)?;
        }
        for v in &self.options {
            ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.name.clear();
        self.description.clear();
        self.type_.clear();
        self.id = 0;
        self.encoding_position = 0;
        self.options.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Field {
        static instance: Field = Field {
            name: ::std::string::String::new(),
            description: ::std::string::String::new(),
            type_: ::protobuf::MessageField::none(),
            id: 0,
            encoding_position: 0,
            options: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Field {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Field").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for Field {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.FieldType)
pub struct FieldType {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.FieldType.nullable)
    pub nullable: bool,
    // message oneof groups
    pub type_info: ::std::option::Option<field_type::Type_info>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.FieldType.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .org.apache.beam.model.pipeline.v1.AtomicType atomic_type = 2;

    pub fn atomic_type(&self) -> AtomicType {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::AtomicType(v)) => ::protobuf::EnumOrUnknown::enum_value_or_default(&v),
            _ => AtomicType::UNSPECIFIED,
        }
    }

    pub fn clear_atomic_type(&mut self) {
        self.type_info = ::std::option::Option::None;
    }

    pub fn has_atomic_type(&self) -> bool {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::AtomicType(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_atomic_type(&mut self, v: AtomicType) {
        self.type_info = ::std::option::Option::Some(field_type::Type_info::AtomicType(::protobuf::EnumOrUnknown::new(v)))
    }

    // .org.apache.beam.model.pipeline.v1.ArrayType array_type = 3;

    pub fn array_type(&self) -> &ArrayType {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::ArrayType(ref v)) => v,
            _ => <ArrayType as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_array_type(&mut self) {
        self.type_info = ::std::option::Option::None;
    }

    pub fn has_array_type(&self) -> bool {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::ArrayType(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_array_type(&mut self, v: ArrayType) {
        self.type_info = ::std::option::Option::Some(field_type::Type_info::ArrayType(v))
    }

    // Mutable pointer to the field.
    pub fn mut_array_type(&mut self) -> &mut ArrayType {
        if let ::std::option::Option::Some(field_type::Type_info::ArrayType(_)) = self.type_info {
        } else {
            self.type_info = ::std::option::Option::Some(field_type::Type_info::ArrayType(ArrayType::new()));
        }
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::ArrayType(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_array_type(&mut self) -> ArrayType {
        if self.has_array_type() {
            match self.type_info.take() {
                ::std::option::Option::Some(field_type::Type_info::ArrayType(v)) => v,
                _ => panic!(),
            }
        } else {
            ArrayType::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.IterableType iterable_type = 4;

    pub fn iterable_type(&self) -> &IterableType {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::IterableType(ref v)) => v,
            _ => <IterableType as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_iterable_type(&mut self) {
        self.type_info = ::std::option::Option::None;
    }

    pub fn has_iterable_type(&self) -> bool {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::IterableType(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_iterable_type(&mut self, v: IterableType) {
        self.type_info = ::std::option::Option::Some(field_type::Type_info::IterableType(v))
    }

    // Mutable pointer to the field.
    pub fn mut_iterable_type(&mut self) -> &mut IterableType {
        if let ::std::option::Option::Some(field_type::Type_info::IterableType(_)) = self.type_info {
        } else {
            self.type_info = ::std::option::Option::Some(field_type::Type_info::IterableType(IterableType::new()));
        }
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::IterableType(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_iterable_type(&mut self) -> IterableType {
        if self.has_iterable_type() {
            match self.type_info.take() {
                ::std::option::Option::Some(field_type::Type_info::IterableType(v)) => v,
                _ => panic!(),
            }
        } else {
            IterableType::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.MapType map_type = 5;

    pub fn map_type(&self) -> &MapType {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::MapType(ref v)) => v,
            _ => <MapType as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_map_type(&mut self) {
        self.type_info = ::std::option::Option::None;
    }

    pub fn has_map_type(&self) -> bool {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::MapType(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_map_type(&mut self, v: MapType) {
        self.type_info = ::std::option::Option::Some(field_type::Type_info::MapType(v))
    }

    // Mutable pointer to the field.
    pub fn mut_map_type(&mut self) -> &mut MapType {
        if let ::std::option::Option::Some(field_type::Type_info::MapType(_)) = self.type_info {
        } else {
            self.type_info = ::std::option::Option::Some(field_type::Type_info::MapType(MapType::new()));
        }
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::MapType(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_map_type(&mut self) -> MapType {
        if self.has_map_type() {
            match self.type_info.take() {
                ::std::option::Option::Some(field_type::Type_info::MapType(v)) => v,
                _ => panic!(),
            }
        } else {
            MapType::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.RowType row_type = 6;

    pub fn row_type(&self) -> &RowType {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::RowType(ref v)) => v,
            _ => <RowType as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_row_type(&mut self) {
        self.type_info = ::std::option::Option::None;
    }

    pub fn has_row_type(&self) -> bool {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::RowType(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_row_type(&mut self, v: RowType) {
        self.type_info = ::std::option::Option::Some(field_type::Type_info::RowType(v))
    }

    // Mutable pointer to the field.
    pub fn mut_row_type(&mut self) -> &mut RowType {
        if let ::std::option::Option::Some(field_type::Type_info::RowType(_)) = self.type_info {
        } else {
            self.type_info = ::std::option::Option::Some(field_type::Type_info::RowType(RowType::new()));
        }
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::RowType(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_row_type(&mut self) -> RowType {
        if self.has_row_type() {
            match self.type_info.take() {
                ::std::option::Option::Some(field_type::Type_info::RowType(v)) => v,
                _ => panic!(),
            }
        } else {
            RowType::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.LogicalType logical_type = 7;

    pub fn logical_type(&self) -> &LogicalType {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::LogicalType(ref v)) => v,
            _ => <LogicalType as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_logical_type(&mut self) {
        self.type_info = ::std::option::Option::None;
    }

    pub fn has_logical_type(&self) -> bool {
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::LogicalType(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_logical_type(&mut self, v: LogicalType) {
        self.type_info = ::std::option::Option::Some(field_type::Type_info::LogicalType(v))
    }

    // Mutable pointer to the field.
    pub fn mut_logical_type(&mut self) -> &mut LogicalType {
        if let ::std::option::Option::Some(field_type::Type_info::LogicalType(_)) = self.type_info {
        } else {
            self.type_info = ::std::option::Option::Some(field_type::Type_info::LogicalType(LogicalType::new()));
        }
        match self.type_info {
            ::std::option::Option::Some(field_type::Type_info::LogicalType(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_logical_type(&mut self) -> LogicalType {
        if self.has_logical_type() {
            match self.type_info.take() {
                ::std::option::Option::Some(field_type::Type_info::LogicalType(v)) => v,
                _ => panic!(),
            }
        } else {
            LogicalType::new()
        }
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(7);
        let mut oneofs = ::std::vec::Vec::with_capacity(1);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "nullable",
            |m: &FieldType| { &m.nullable },
            |m: &mut FieldType| { &mut m.nullable },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_enum_accessors::<_, _>(
            "atomic_type",
            |message: &FieldType| match &message.type_info {
                ::std::option::Option::Some(field_type::Type_info::AtomicType(e)) => ::std::option::Option::Some(*e),
                _ => ::std::option::Option::None,
            },
            |message: &mut FieldType, e: ::protobuf::EnumOrUnknown<AtomicType>| {
                message.type_info = ::std::option::Option::Some(field_type::Type_info::AtomicType(e));
            },
            AtomicType::UNSPECIFIED,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, ArrayType>(
            "array_type",
            FieldType::has_array_type,
            FieldType::array_type,
            FieldType::mut_array_type,
            FieldType::set_array_type,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, IterableType>(
            "iterable_type",
            FieldType::has_iterable_type,
            FieldType::iterable_type,
            FieldType::mut_iterable_type,
            FieldType::set_iterable_type,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, MapType>(
            "map_type",
            FieldType::has_map_type,
            FieldType::map_type,
            FieldType::mut_map_type,
            FieldType::set_map_type,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, RowType>(
            "row_type",
            FieldType::has_row_type,
            FieldType::row_type,
            FieldType::mut_row_type,
            FieldType::set_row_type,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, LogicalType>(
            "logical_type",
            FieldType::has_logical_type,
            FieldType::logical_type,
            FieldType::mut_logical_type,
            FieldType::set_logical_type,
        ));
        oneofs.push(field_type::Type_info::generated_oneof_descriptor_data());
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FieldType>(
            "FieldType",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for FieldType {
    const NAME: &'static str = "FieldType";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.nullable = is.read_bool()?;
                },
                16 => {
                    self.type_info = ::std::option::Option::Some(field_type::Type_info::AtomicType(is.read_enum_or_unknown()?));
                },
                26 => {
                    self.type_info = ::std::option::Option::Some(field_type::Type_info::ArrayType(is.read_message()?));
                },
                34 => {
                    self.type_info = ::std::option::Option::Some(field_type::Type_info::IterableType(is.read_message()?));
                },
                42 => {
                    self.type_info = ::std::option::Option::Some(field_type::Type_info::MapType(is.read_message()?));
                },
                50 => {
                    self.type_info = ::std::option::Option::Some(field_type::Type_info::RowType(is.read_message()?));
                },
                58 => {
                    self.type_info = ::std::option::Option::Some(field_type::Type_info::LogicalType(is.read_message()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.nullable != false {
            my_size += 1 + 1;
        }
        if let ::std::option::Option::Some(ref v) = self.type_info {
            match v {
                &field_type::Type_info::AtomicType(v) => {
                    my_size += ::protobuf::rt::int32_size(2, v.value());
                },
                &field_type::Type_info::ArrayType(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_type::Type_info::IterableType(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_type::Type_info::MapType(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_type::Type_info::RowType(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_type::Type_info::LogicalType(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.nullable != false {
            os.write_bool(1, self.nullable)?;
        }
        if let ::std::option::Option::Some(ref v) = self.type_info {
            match v {
                &field_type::Type_info::AtomicType(v) => {
                    os.write_enum(2, ::protobuf::EnumOrUnknown::value(&v))?;
                },
                &field_type::Type_info::ArrayType(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &field_type::Type_info::IterableType(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &field_type::Type_info::MapType(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &field_type::Type_info::RowType(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &field_type::Type_info::LogicalType(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.nullable = false;
        self.type_info = ::std::option::Option::None;
        self.type_info = ::std::option::Option::None;
        self.type_info = ::std::option::Option::None;
        self.type_info = ::std::option::Option::None;
        self.type_info = ::std::option::Option::None;
        self.type_info = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static FieldType {
        static instance: FieldType = FieldType {
            nullable: false,
            type_info: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for FieldType {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("FieldType").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for FieldType {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `FieldType`
pub mod field_type {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:org.apache.beam.model.pipeline.v1.FieldType.type_info)
    pub enum Type_info {
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldType.atomic_type)
        AtomicType(::protobuf::EnumOrUnknown<super::AtomicType>),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldType.array_type)
        ArrayType(super::ArrayType),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldType.iterable_type)
        IterableType(super::IterableType),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldType.map_type)
        MapType(super::MapType),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldType.row_type)
        RowType(super::RowType),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldType.logical_type)
        LogicalType(super::LogicalType),
    }

    impl ::protobuf::Oneof for Type_info {
    }

    impl ::protobuf::OneofFull for Type_info {
        fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| <super::FieldType as ::protobuf::MessageFull>::descriptor().oneof_by_name("type_info").unwrap()).clone()
        }
    }

    impl Type_info {
        pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
            ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Type_info>("type_info")
        }
    }
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.ArrayType)
pub struct ArrayType {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.ArrayType.element_type)
    pub element_type: ::protobuf::MessageField<FieldType>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.ArrayType.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldType>(
            "element_type",
            |m: &ArrayType| { &m.element_type },
            |m: &mut ArrayType| { &mut m.element_type },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ArrayType>(
            "ArrayType",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for ArrayType {
    const NAME: &'static str = "ArrayType";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.element_type)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.element_type.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.element_type.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.element_type.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ArrayType {
        static instance: ArrayType = ArrayType {
            element_type: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for ArrayType {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("ArrayType").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for ArrayType {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.IterableType)
pub struct IterableType {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.IterableType.element_type)
    pub element_type: ::protobuf::MessageField<FieldType>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.IterableType.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldType>(
            "element_type",
            |m: &IterableType| { &m.element_type },
            |m: &mut IterableType| { &mut m.element_type },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<IterableType>(
            "IterableType",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for IterableType {
    const NAME: &'static str = "IterableType";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.element_type)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.element_type.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.element_type.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.element_type.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static IterableType {
        static instance: IterableType = IterableType {
            element_type: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for IterableType {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("IterableType").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for IterableType {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.MapType)
pub struct MapType {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.MapType.key_type)
    pub key_type: ::protobuf::MessageField<FieldType>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.MapType.value_type)
    pub value_type: ::protobuf::MessageField<FieldType>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.MapType.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldType>(
            "key_type",
            |m: &MapType| { &m.key_type },
            |m: &mut MapType| { &mut m.key_type },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldType>(
            "value_type",
            |m: &MapType| { &m.value_type },
            |m: &mut MapType| { &mut m.value_type },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MapType>(
            "MapType",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for MapType {
    const NAME: &'static str = "MapType";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.key_type)?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.value_type)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.key_type.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.value_type.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.key_type.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.value_type.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.key_type.clear();
        self.value_type.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static MapType {
        static instance: MapType = MapType {
            key_type: ::protobuf::MessageField::none(),
            value_type: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for MapType {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("MapType").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for MapType {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.RowType)
pub struct RowType {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.RowType.schema)
    pub schema: ::protobuf::MessageField<Schema>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.RowType.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Schema>(
            "schema",
            |m: &RowType| { &m.schema },
            |m: &mut RowType| { &mut m.schema },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RowType>(
            "RowType",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for RowType {
    const NAME: &'static str = "RowType";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.schema)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.schema.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.schema.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.schema.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static RowType {
        static instance: RowType = RowType {
            schema: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for RowType {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("RowType").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for RowType {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.LogicalType)
pub struct LogicalType {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.LogicalType.urn)
    pub urn: ::std::string::String,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.LogicalType.payload)
    pub payload: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.LogicalType.representation)
    pub representation: ::protobuf::MessageField<FieldType>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.LogicalType.argument_type)
    pub argument_type: ::protobuf::MessageField<FieldType>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.LogicalType.argument)
    pub argument: ::protobuf::MessageField<FieldValue>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.LogicalType.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(5);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "urn",
            |m: &LogicalType| { &m.urn },
            |m: &mut LogicalType| { &mut m.urn },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "payload",
            |m: &LogicalType| { &m.payload },
            |m: &mut LogicalType| { &mut m.payload },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldType>(
            "representation",
            |m: &LogicalType| { &m.representation },
            |m: &mut LogicalType| { &mut m.representation },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldType>(
            "argument_type",
            |m: &LogicalType| { &m.argument_type },
            |m: &mut LogicalType| { &mut m.argument_type },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldValue>(
            "argument",
            |m: &LogicalType| { &m.argument },
            |m: &mut LogicalType| { &mut m.argument },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<LogicalType>(
            "LogicalType",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for LogicalType {
    const NAME: &'static str = "LogicalType";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.urn = is.read_string()?;
                },
                18 => {
                    self.payload = is.read_bytes()?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.representation)?;
                },
                34 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.argument_type)?;
                },
                42 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.argument)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.urn.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.urn);
        }
        if !self.payload.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.payload);
        }
        if let Some(v) = self.representation.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.argument_type.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.argument.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.urn.is_empty() {
            os.write_string(1, &self.urn)?;
        }
        if !self.payload.is_empty() {
            os.write_bytes(2, &self.payload)?;
        }
        if let Some(v) = self.representation.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if let Some(v) = self.argument_type.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        }
        if let Some(v) = self.argument.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.urn.clear();
        self.payload.clear();
        self.representation.clear();
        self.argument_type.clear();
        self.argument.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static LogicalType {
        static instance: LogicalType = LogicalType {
            urn: ::std::string::String::new(),
            payload: ::std::vec::Vec::new(),
            representation: ::protobuf::MessageField::none(),
            argument_type: ::protobuf::MessageField::none(),
            argument: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for LogicalType {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("LogicalType").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for LogicalType {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.LogicalTypes)
pub struct LogicalTypes {
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.LogicalTypes.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<LogicalTypes>(
            "LogicalTypes",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for LogicalTypes {
    const NAME: &'static str = "LogicalTypes";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static LogicalTypes {
        static instance: LogicalTypes = LogicalTypes {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for LogicalTypes {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("LogicalTypes").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for LogicalTypes {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `LogicalTypes`
pub mod logical_types {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:org.apache.beam.model.pipeline.v1.LogicalTypes.Enum)
    pub enum Enum {
        // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.LogicalTypes.Enum.PYTHON_CALLABLE)
        PYTHON_CALLABLE = 0,
        // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.LogicalTypes.Enum.MICROS_INSTANT)
        MICROS_INSTANT = 1,
    }

    impl ::protobuf::Enum for Enum {
        const NAME: &'static str = "Enum";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Enum> {
            match value {
                0 => ::std::option::Option::Some(Enum::PYTHON_CALLABLE),
                1 => ::std::option::Option::Some(Enum::MICROS_INSTANT),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Enum] = &[
            Enum::PYTHON_CALLABLE,
            Enum::MICROS_INSTANT,
        ];
    }

    impl ::protobuf::EnumFull for Enum {
        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("LogicalTypes.Enum").unwrap()).clone()
        }

        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
            let index = *self as usize;
            Self::enum_descriptor().value_by_index(index)
        }
    }

    impl ::std::default::Default for Enum {
        fn default() -> Self {
            Enum::PYTHON_CALLABLE
        }
    }

    impl Enum {
        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Enum>("LogicalTypes.Enum")
        }
    }
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.Option)
pub struct Option {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Option.name)
    pub name: ::std::string::String,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Option.type)
    pub type_: ::protobuf::MessageField<FieldType>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Option.value)
    pub value: ::protobuf::MessageField<FieldValue>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.Option.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "name",
            |m: &Option| { &m.name },
            |m: &mut Option| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldType>(
            "type",
            |m: &Option| { &m.type_ },
            |m: &mut Option| { &mut m.type_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldValue>(
            "value",
            |m: &Option| { &m.value },
            |m: &mut Option| { &mut m.value },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Option>(
            "Option",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Option {
    const NAME: &'static str = "Option";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = is.read_string()?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.type_)?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.value)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if let Some(v) = self.type_.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.value.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if let Some(v) = self.type_.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.value.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.name.clear();
        self.type_.clear();
        self.value.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Option {
        static instance: Option = Option {
            name: ::std::string::String::new(),
            type_: ::protobuf::MessageField::none(),
            value: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Option {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Option").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for Option {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.Row)
pub struct Row {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.Row.values)
    pub values: ::std::vec::Vec<FieldValue>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.Row.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "values",
            |m: &Row| { &m.values },
            |m: &mut Row| { &mut m.values },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Row>(
            "Row",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Row {
    const NAME: &'static str = "Row";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.values.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.values {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.values.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Row {
        static instance: Row = Row {
            values: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Row {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Row").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for Row {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.FieldValue)
pub struct FieldValue {
    // message oneof groups
    pub field_value: ::std::option::Option<field_value::Field_value>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.FieldValue.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .org.apache.beam.model.pipeline.v1.AtomicTypeValue atomic_value = 1;

    pub fn atomic_value(&self) -> &AtomicTypeValue {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::AtomicValue(ref v)) => v,
            _ => <AtomicTypeValue as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_atomic_value(&mut self) {
        self.field_value = ::std::option::Option::None;
    }

    pub fn has_atomic_value(&self) -> bool {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::AtomicValue(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_atomic_value(&mut self, v: AtomicTypeValue) {
        self.field_value = ::std::option::Option::Some(field_value::Field_value::AtomicValue(v))
    }

    // Mutable pointer to the field.
    pub fn mut_atomic_value(&mut self) -> &mut AtomicTypeValue {
        if let ::std::option::Option::Some(field_value::Field_value::AtomicValue(_)) = self.field_value {
        } else {
            self.field_value = ::std::option::Option::Some(field_value::Field_value::AtomicValue(AtomicTypeValue::new()));
        }
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::AtomicValue(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_atomic_value(&mut self) -> AtomicTypeValue {
        if self.has_atomic_value() {
            match self.field_value.take() {
                ::std::option::Option::Some(field_value::Field_value::AtomicValue(v)) => v,
                _ => panic!(),
            }
        } else {
            AtomicTypeValue::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.ArrayTypeValue array_value = 2;

    pub fn array_value(&self) -> &ArrayTypeValue {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::ArrayValue(ref v)) => v,
            _ => <ArrayTypeValue as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_array_value(&mut self) {
        self.field_value = ::std::option::Option::None;
    }

    pub fn has_array_value(&self) -> bool {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::ArrayValue(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_array_value(&mut self, v: ArrayTypeValue) {
        self.field_value = ::std::option::Option::Some(field_value::Field_value::ArrayValue(v))
    }

    // Mutable pointer to the field.
    pub fn mut_array_value(&mut self) -> &mut ArrayTypeValue {
        if let ::std::option::Option::Some(field_value::Field_value::ArrayValue(_)) = self.field_value {
        } else {
            self.field_value = ::std::option::Option::Some(field_value::Field_value::ArrayValue(ArrayTypeValue::new()));
        }
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::ArrayValue(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_array_value(&mut self) -> ArrayTypeValue {
        if self.has_array_value() {
            match self.field_value.take() {
                ::std::option::Option::Some(field_value::Field_value::ArrayValue(v)) => v,
                _ => panic!(),
            }
        } else {
            ArrayTypeValue::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.IterableTypeValue iterable_value = 3;

    pub fn iterable_value(&self) -> &IterableTypeValue {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::IterableValue(ref v)) => v,
            _ => <IterableTypeValue as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_iterable_value(&mut self) {
        self.field_value = ::std::option::Option::None;
    }

    pub fn has_iterable_value(&self) -> bool {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::IterableValue(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_iterable_value(&mut self, v: IterableTypeValue) {
        self.field_value = ::std::option::Option::Some(field_value::Field_value::IterableValue(v))
    }

    // Mutable pointer to the field.
    pub fn mut_iterable_value(&mut self) -> &mut IterableTypeValue {
        if let ::std::option::Option::Some(field_value::Field_value::IterableValue(_)) = self.field_value {
        } else {
            self.field_value = ::std::option::Option::Some(field_value::Field_value::IterableValue(IterableTypeValue::new()));
        }
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::IterableValue(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_iterable_value(&mut self) -> IterableTypeValue {
        if self.has_iterable_value() {
            match self.field_value.take() {
                ::std::option::Option::Some(field_value::Field_value::IterableValue(v)) => v,
                _ => panic!(),
            }
        } else {
            IterableTypeValue::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.MapTypeValue map_value = 4;

    pub fn map_value(&self) -> &MapTypeValue {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::MapValue(ref v)) => v,
            _ => <MapTypeValue as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_map_value(&mut self) {
        self.field_value = ::std::option::Option::None;
    }

    pub fn has_map_value(&self) -> bool {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::MapValue(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_map_value(&mut self, v: MapTypeValue) {
        self.field_value = ::std::option::Option::Some(field_value::Field_value::MapValue(v))
    }

    // Mutable pointer to the field.
    pub fn mut_map_value(&mut self) -> &mut MapTypeValue {
        if let ::std::option::Option::Some(field_value::Field_value::MapValue(_)) = self.field_value {
        } else {
            self.field_value = ::std::option::Option::Some(field_value::Field_value::MapValue(MapTypeValue::new()));
        }
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::MapValue(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_map_value(&mut self) -> MapTypeValue {
        if self.has_map_value() {
            match self.field_value.take() {
                ::std::option::Option::Some(field_value::Field_value::MapValue(v)) => v,
                _ => panic!(),
            }
        } else {
            MapTypeValue::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.Row row_value = 5;

    pub fn row_value(&self) -> &Row {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::RowValue(ref v)) => v,
            _ => <Row as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_row_value(&mut self) {
        self.field_value = ::std::option::Option::None;
    }

    pub fn has_row_value(&self) -> bool {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::RowValue(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_row_value(&mut self, v: Row) {
        self.field_value = ::std::option::Option::Some(field_value::Field_value::RowValue(v))
    }

    // Mutable pointer to the field.
    pub fn mut_row_value(&mut self) -> &mut Row {
        if let ::std::option::Option::Some(field_value::Field_value::RowValue(_)) = self.field_value {
        } else {
            self.field_value = ::std::option::Option::Some(field_value::Field_value::RowValue(Row::new()));
        }
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::RowValue(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_row_value(&mut self) -> Row {
        if self.has_row_value() {
            match self.field_value.take() {
                ::std::option::Option::Some(field_value::Field_value::RowValue(v)) => v,
                _ => panic!(),
            }
        } else {
            Row::new()
        }
    }

    // .org.apache.beam.model.pipeline.v1.LogicalTypeValue logical_type_value = 6;

    pub fn logical_type_value(&self) -> &LogicalTypeValue {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::LogicalTypeValue(ref v)) => v,
            _ => <LogicalTypeValue as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_logical_type_value(&mut self) {
        self.field_value = ::std::option::Option::None;
    }

    pub fn has_logical_type_value(&self) -> bool {
        match self.field_value {
            ::std::option::Option::Some(field_value::Field_value::LogicalTypeValue(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_logical_type_value(&mut self, v: LogicalTypeValue) {
        self.field_value = ::std::option::Option::Some(field_value::Field_value::LogicalTypeValue(v))
    }

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

    // Take field
    pub fn take_logical_type_value(&mut self) -> LogicalTypeValue {
        if self.has_logical_type_value() {
            match self.field_value.take() {
                ::std::option::Option::Some(field_value::Field_value::LogicalTypeValue(v)) => v,
                _ => panic!(),
            }
        } else {
            LogicalTypeValue::new()
        }
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(6);
        let mut oneofs = ::std::vec::Vec::with_capacity(1);
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, AtomicTypeValue>(
            "atomic_value",
            FieldValue::has_atomic_value,
            FieldValue::atomic_value,
            FieldValue::mut_atomic_value,
            FieldValue::set_atomic_value,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, ArrayTypeValue>(
            "array_value",
            FieldValue::has_array_value,
            FieldValue::array_value,
            FieldValue::mut_array_value,
            FieldValue::set_array_value,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, IterableTypeValue>(
            "iterable_value",
            FieldValue::has_iterable_value,
            FieldValue::iterable_value,
            FieldValue::mut_iterable_value,
            FieldValue::set_iterable_value,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, MapTypeValue>(
            "map_value",
            FieldValue::has_map_value,
            FieldValue::map_value,
            FieldValue::mut_map_value,
            FieldValue::set_map_value,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, Row>(
            "row_value",
            FieldValue::has_row_value,
            FieldValue::row_value,
            FieldValue::mut_row_value,
            FieldValue::set_row_value,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, LogicalTypeValue>(
            "logical_type_value",
            FieldValue::has_logical_type_value,
            FieldValue::logical_type_value,
            FieldValue::mut_logical_type_value,
            FieldValue::set_logical_type_value,
        ));
        oneofs.push(field_value::Field_value::generated_oneof_descriptor_data());
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FieldValue>(
            "FieldValue",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for FieldValue {
    const NAME: &'static str = "FieldValue";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.field_value = ::std::option::Option::Some(field_value::Field_value::AtomicValue(is.read_message()?));
                },
                18 => {
                    self.field_value = ::std::option::Option::Some(field_value::Field_value::ArrayValue(is.read_message()?));
                },
                26 => {
                    self.field_value = ::std::option::Option::Some(field_value::Field_value::IterableValue(is.read_message()?));
                },
                34 => {
                    self.field_value = ::std::option::Option::Some(field_value::Field_value::MapValue(is.read_message()?));
                },
                42 => {
                    self.field_value = ::std::option::Option::Some(field_value::Field_value::RowValue(is.read_message()?));
                },
                50 => {
                    self.field_value = ::std::option::Option::Some(field_value::Field_value::LogicalTypeValue(is.read_message()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.field_value {
            match v {
                &field_value::Field_value::AtomicValue(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_value::Field_value::ArrayValue(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_value::Field_value::IterableValue(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_value::Field_value::MapValue(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_value::Field_value::RowValue(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &field_value::Field_value::LogicalTypeValue(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let ::std::option::Option::Some(ref v) = self.field_value {
            match v {
                &field_value::Field_value::AtomicValue(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                },
                &field_value::Field_value::ArrayValue(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &field_value::Field_value::IterableValue(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &field_value::Field_value::MapValue(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &field_value::Field_value::RowValue(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &field_value::Field_value::LogicalTypeValue(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.field_value = ::std::option::Option::None;
        self.field_value = ::std::option::Option::None;
        self.field_value = ::std::option::Option::None;
        self.field_value = ::std::option::Option::None;
        self.field_value = ::std::option::Option::None;
        self.field_value = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static FieldValue {
        static instance: FieldValue = FieldValue {
            field_value: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for FieldValue {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("FieldValue").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for FieldValue {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `FieldValue`
pub mod field_value {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:org.apache.beam.model.pipeline.v1.FieldValue.field_value)
    pub enum Field_value {
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldValue.atomic_value)
        AtomicValue(super::AtomicTypeValue),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldValue.array_value)
        ArrayValue(super::ArrayTypeValue),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldValue.iterable_value)
        IterableValue(super::IterableTypeValue),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldValue.map_value)
        MapValue(super::MapTypeValue),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldValue.row_value)
        RowValue(super::Row),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.FieldValue.logical_type_value)
        LogicalTypeValue(super::LogicalTypeValue),
    }

    impl ::protobuf::Oneof for Field_value {
    }

    impl ::protobuf::OneofFull for Field_value {
        fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| <super::FieldValue as ::protobuf::MessageFull>::descriptor().oneof_by_name("field_value").unwrap()).clone()
        }
    }

    impl Field_value {
        pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
            ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Field_value>("field_value")
        }
    }
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.AtomicTypeValue)
pub struct AtomicTypeValue {
    // message oneof groups
    pub value: ::std::option::Option<atomic_type_value::Value>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // int32 byte = 1;

    pub fn byte(&self) -> i32 {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Byte(v)) => v,
            _ => 0,
        }
    }

    pub fn clear_byte(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_byte(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Byte(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_byte(&mut self, v: i32) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::Byte(v))
    }

    // int32 int16 = 2;

    pub fn int16(&self) -> i32 {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Int16(v)) => v,
            _ => 0,
        }
    }

    pub fn clear_int16(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_int16(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Int16(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int16(&mut self, v: i32) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::Int16(v))
    }

    // int32 int32 = 3;

    pub fn int32(&self) -> i32 {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Int32(v)) => v,
            _ => 0,
        }
    }

    pub fn clear_int32(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_int32(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Int32(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int32(&mut self, v: i32) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::Int32(v))
    }

    // int64 int64 = 4;

    pub fn int64(&self) -> i64 {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Int64(v)) => v,
            _ => 0,
        }
    }

    pub fn clear_int64(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_int64(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Int64(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int64(&mut self, v: i64) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::Int64(v))
    }

    // float float = 5;

    pub fn float(&self) -> f32 {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Float(v)) => v,
            _ => 0.,
        }
    }

    pub fn clear_float(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_float(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Float(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_float(&mut self, v: f32) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::Float(v))
    }

    // double double = 6;

    pub fn double(&self) -> f64 {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Double(v)) => v,
            _ => 0.,
        }
    }

    pub fn clear_double(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_double(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Double(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_double(&mut self, v: f64) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::Double(v))
    }

    // string string = 7;

    pub fn string(&self) -> &str {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::String(ref v)) => v,
            _ => "",
        }
    }

    pub fn clear_string(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_string(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::String(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_string(&mut self, v: ::std::string::String) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::String(v))
    }

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

    // Take field
    pub fn take_string(&mut self) -> ::std::string::String {
        if self.has_string() {
            match self.value.take() {
                ::std::option::Option::Some(atomic_type_value::Value::String(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    // bool boolean = 8;

    pub fn boolean(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Boolean(v)) => v,
            _ => false,
        }
    }

    pub fn clear_boolean(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_boolean(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Boolean(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_boolean(&mut self, v: bool) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::Boolean(v))
    }

    // bytes bytes = 9;

    pub fn bytes(&self) -> &[u8] {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Bytes(ref v)) => v,
            _ => &[],
        }
    }

    pub fn clear_bytes(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_bytes(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Bytes(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bytes(&mut self, v: ::std::vec::Vec<u8>) {
        self.value = ::std::option::Option::Some(atomic_type_value::Value::Bytes(v))
    }

    // Mutable pointer to the field.
    pub fn mut_bytes(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(atomic_type_value::Value::Bytes(_)) = self.value {
        } else {
            self.value = ::std::option::Option::Some(atomic_type_value::Value::Bytes(::std::vec::Vec::new()));
        }
        match self.value {
            ::std::option::Option::Some(atomic_type_value::Value::Bytes(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_bytes(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_bytes() {
            match self.value.take() {
                ::std::option::Option::Some(atomic_type_value::Value::Bytes(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(9);
        let mut oneofs = ::std::vec::Vec::with_capacity(1);
        fields.push(::protobuf::reflect::rt::v2::make_oneof_copy_has_get_set_simpler_accessors::<_, _>(
            "byte",
            AtomicTypeValue::has_byte,
            AtomicTypeValue::byte,
            AtomicTypeValue::set_byte,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_copy_has_get_set_simpler_accessors::<_, _>(
            "int16",
            AtomicTypeValue::has_int16,
            AtomicTypeValue::int16,
            AtomicTypeValue::set_int16,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_copy_has_get_set_simpler_accessors::<_, _>(
            "int32",
            AtomicTypeValue::has_int32,
            AtomicTypeValue::int32,
            AtomicTypeValue::set_int32,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_copy_has_get_set_simpler_accessors::<_, _>(
            "int64",
            AtomicTypeValue::has_int64,
            AtomicTypeValue::int64,
            AtomicTypeValue::set_int64,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_copy_has_get_set_simpler_accessors::<_, _>(
            "float",
            AtomicTypeValue::has_float,
            AtomicTypeValue::float,
            AtomicTypeValue::set_float,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_copy_has_get_set_simpler_accessors::<_, _>(
            "double",
            AtomicTypeValue::has_double,
            AtomicTypeValue::double,
            AtomicTypeValue::set_double,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_deref_has_get_set_simpler_accessor::<_, _>(
            "string",
            AtomicTypeValue::has_string,
            AtomicTypeValue::string,
            AtomicTypeValue::set_string,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_copy_has_get_set_simpler_accessors::<_, _>(
            "boolean",
            AtomicTypeValue::has_boolean,
            AtomicTypeValue::boolean,
            AtomicTypeValue::set_boolean,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_deref_has_get_set_simpler_accessor::<_, _>(
            "bytes",
            AtomicTypeValue::has_bytes,
            AtomicTypeValue::bytes,
            AtomicTypeValue::set_bytes,
        ));
        oneofs.push(atomic_type_value::Value::generated_oneof_descriptor_data());
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AtomicTypeValue>(
            "AtomicTypeValue",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for AtomicTypeValue {
    const NAME: &'static str = "AtomicTypeValue";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::Byte(is.read_int32()?));
                },
                16 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::Int16(is.read_int32()?));
                },
                24 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::Int32(is.read_int32()?));
                },
                32 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::Int64(is.read_int64()?));
                },
                45 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::Float(is.read_float()?));
                },
                49 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::Double(is.read_double()?));
                },
                58 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::String(is.read_string()?));
                },
                64 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::Boolean(is.read_bool()?));
                },
                74 => {
                    self.value = ::std::option::Option::Some(atomic_type_value::Value::Bytes(is.read_bytes()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.value {
            match v {
                &atomic_type_value::Value::Byte(v) => {
                    my_size += ::protobuf::rt::int32_size(1, v);
                },
                &atomic_type_value::Value::Int16(v) => {
                    my_size += ::protobuf::rt::int32_size(2, v);
                },
                &atomic_type_value::Value::Int32(v) => {
                    my_size += ::protobuf::rt::int32_size(3, v);
                },
                &atomic_type_value::Value::Int64(v) => {
                    my_size += ::protobuf::rt::int64_size(4, v);
                },
                &atomic_type_value::Value::Float(v) => {
                    my_size += 1 + 4;
                },
                &atomic_type_value::Value::Double(v) => {
                    my_size += 1 + 8;
                },
                &atomic_type_value::Value::String(ref v) => {
                    my_size += ::protobuf::rt::string_size(7, &v);
                },
                &atomic_type_value::Value::Boolean(v) => {
                    my_size += 1 + 1;
                },
                &atomic_type_value::Value::Bytes(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(9, &v);
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let ::std::option::Option::Some(ref v) = self.value {
            match v {
                &atomic_type_value::Value::Byte(v) => {
                    os.write_int32(1, v)?;
                },
                &atomic_type_value::Value::Int16(v) => {
                    os.write_int32(2, v)?;
                },
                &atomic_type_value::Value::Int32(v) => {
                    os.write_int32(3, v)?;
                },
                &atomic_type_value::Value::Int64(v) => {
                    os.write_int64(4, v)?;
                },
                &atomic_type_value::Value::Float(v) => {
                    os.write_float(5, v)?;
                },
                &atomic_type_value::Value::Double(v) => {
                    os.write_double(6, v)?;
                },
                &atomic_type_value::Value::String(ref v) => {
                    os.write_string(7, v)?;
                },
                &atomic_type_value::Value::Boolean(v) => {
                    os.write_bool(8, v)?;
                },
                &atomic_type_value::Value::Bytes(ref v) => {
                    os.write_bytes(9, v)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static AtomicTypeValue {
        static instance: AtomicTypeValue = AtomicTypeValue {
            value: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for AtomicTypeValue {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("AtomicTypeValue").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for AtomicTypeValue {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `AtomicTypeValue`
pub mod atomic_type_value {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:org.apache.beam.model.pipeline.v1.AtomicTypeValue.value)
    pub enum Value {
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.byte)
        Byte(i32),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.int16)
        Int16(i32),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.int32)
        Int32(i32),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.int64)
        Int64(i64),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.float)
        Float(f32),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.double)
        Double(f64),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.string)
        String(::std::string::String),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.boolean)
        Boolean(bool),
        // @@protoc_insertion_point(oneof_field:org.apache.beam.model.pipeline.v1.AtomicTypeValue.bytes)
        Bytes(::std::vec::Vec<u8>),
    }

    impl ::protobuf::Oneof for Value {
    }

    impl ::protobuf::OneofFull for Value {
        fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| <super::AtomicTypeValue as ::protobuf::MessageFull>::descriptor().oneof_by_name("value").unwrap()).clone()
        }
    }

    impl Value {
        pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
            ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Value>("value")
        }
    }
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.ArrayTypeValue)
pub struct ArrayTypeValue {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.ArrayTypeValue.element)
    pub element: ::std::vec::Vec<FieldValue>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.ArrayTypeValue.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "element",
            |m: &ArrayTypeValue| { &m.element },
            |m: &mut ArrayTypeValue| { &mut m.element },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ArrayTypeValue>(
            "ArrayTypeValue",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for ArrayTypeValue {
    const NAME: &'static str = "ArrayTypeValue";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.element.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.element {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.element.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ArrayTypeValue {
        static instance: ArrayTypeValue = ArrayTypeValue {
            element: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for ArrayTypeValue {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("ArrayTypeValue").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for ArrayTypeValue {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.IterableTypeValue)
pub struct IterableTypeValue {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.IterableTypeValue.element)
    pub element: ::std::vec::Vec<FieldValue>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.IterableTypeValue.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "element",
            |m: &IterableTypeValue| { &m.element },
            |m: &mut IterableTypeValue| { &mut m.element },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<IterableTypeValue>(
            "IterableTypeValue",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for IterableTypeValue {
    const NAME: &'static str = "IterableTypeValue";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.element.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.element {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.element.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static IterableTypeValue {
        static instance: IterableTypeValue = IterableTypeValue {
            element: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for IterableTypeValue {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("IterableTypeValue").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for IterableTypeValue {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.MapTypeValue)
pub struct MapTypeValue {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.MapTypeValue.entries)
    pub entries: ::std::vec::Vec<MapTypeEntry>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.MapTypeValue.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "entries",
            |m: &MapTypeValue| { &m.entries },
            |m: &mut MapTypeValue| { &mut m.entries },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MapTypeValue>(
            "MapTypeValue",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for MapTypeValue {
    const NAME: &'static str = "MapTypeValue";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.entries.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.entries {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.entries.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static MapTypeValue {
        static instance: MapTypeValue = MapTypeValue {
            entries: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for MapTypeValue {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("MapTypeValue").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for MapTypeValue {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.MapTypeEntry)
pub struct MapTypeEntry {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.MapTypeEntry.key)
    pub key: ::protobuf::MessageField<FieldValue>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.MapTypeEntry.value)
    pub value: ::protobuf::MessageField<FieldValue>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.MapTypeEntry.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldValue>(
            "key",
            |m: &MapTypeEntry| { &m.key },
            |m: &mut MapTypeEntry| { &mut m.key },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldValue>(
            "value",
            |m: &MapTypeEntry| { &m.value },
            |m: &mut MapTypeEntry| { &mut m.value },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MapTypeEntry>(
            "MapTypeEntry",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for MapTypeEntry {
    const NAME: &'static str = "MapTypeEntry";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.key)?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.value)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.key.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.value.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.key.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.value.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.key.clear();
        self.value.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static MapTypeEntry {
        static instance: MapTypeEntry = MapTypeEntry {
            key: ::protobuf::MessageField::none(),
            value: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for MapTypeEntry {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("MapTypeEntry").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for MapTypeEntry {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.LogicalTypeValue)
pub struct LogicalTypeValue {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.LogicalTypeValue.value)
    pub value: ::protobuf::MessageField<FieldValue>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.LogicalTypeValue.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FieldValue>(
            "value",
            |m: &LogicalTypeValue| { &m.value },
            |m: &mut LogicalTypeValue| { &mut m.value },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<LogicalTypeValue>(
            "LogicalTypeValue",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for LogicalTypeValue {
    const NAME: &'static str = "LogicalTypeValue";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.value)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.value.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.value.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.value.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static LogicalTypeValue {
        static instance: LogicalTypeValue = LogicalTypeValue {
            value: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for LogicalTypeValue {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("LogicalTypeValue").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for LogicalTypeValue {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:org.apache.beam.model.pipeline.v1.AtomicType)
pub enum AtomicType {
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.UNSPECIFIED)
    UNSPECIFIED = 0,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.BYTE)
    BYTE = 1,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.INT16)
    INT16 = 2,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.INT32)
    INT32 = 3,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.INT64)
    INT64 = 4,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.FLOAT)
    FLOAT = 5,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.DOUBLE)
    DOUBLE = 6,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.STRING)
    STRING = 7,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.BOOLEAN)
    BOOLEAN = 8,
    // @@protoc_insertion_point(enum_value:org.apache.beam.model.pipeline.v1.AtomicType.BYTES)
    BYTES = 9,
}

impl ::protobuf::Enum for AtomicType {
    const NAME: &'static str = "AtomicType";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<AtomicType> {
        match value {
            0 => ::std::option::Option::Some(AtomicType::UNSPECIFIED),
            1 => ::std::option::Option::Some(AtomicType::BYTE),
            2 => ::std::option::Option::Some(AtomicType::INT16),
            3 => ::std::option::Option::Some(AtomicType::INT32),
            4 => ::std::option::Option::Some(AtomicType::INT64),
            5 => ::std::option::Option::Some(AtomicType::FLOAT),
            6 => ::std::option::Option::Some(AtomicType::DOUBLE),
            7 => ::std::option::Option::Some(AtomicType::STRING),
            8 => ::std::option::Option::Some(AtomicType::BOOLEAN),
            9 => ::std::option::Option::Some(AtomicType::BYTES),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [AtomicType] = &[
        AtomicType::UNSPECIFIED,
        AtomicType::BYTE,
        AtomicType::INT16,
        AtomicType::INT32,
        AtomicType::INT64,
        AtomicType::FLOAT,
        AtomicType::DOUBLE,
        AtomicType::STRING,
        AtomicType::BOOLEAN,
        AtomicType::BYTES,
    ];
}

impl ::protobuf::EnumFull for AtomicType {
    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().enum_by_package_relative_name("AtomicType").unwrap()).clone()
    }

    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
        let index = *self as usize;
        Self::enum_descriptor().value_by_index(index)
    }
}

impl ::std::default::Default for AtomicType {
    fn default() -> Self {
        AtomicType::UNSPECIFIED
    }
}

impl AtomicType {
    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<AtomicType>("AtomicType")
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n.org/apache/beam/model/pipeline/v1/schema.proto\x12!org.apache.beam.mo\
    del.pipeline.v1\x1a7org/apache/beam/model/pipeline/v1/beam_runner_api.pr\
    oto\"\xd5\x01\n\x06Schema\x12@\n\x06fields\x18\x01\x20\x03(\x0b2(.org.ap\
    ache.beam.model.pipeline.v1.FieldR\x06fields\x12\x0e\n\x02id\x18\x02\x20\
    \x01(\tR\x02id\x12C\n\x07options\x18\x03\x20\x03(\x0b2).org.apache.beam.\
    model.pipeline.v1.OptionR\x07options\x124\n\x16encoding_positions_set\
    \x18\x04\x20\x01(\x08R\x14encodingPositionsSet\"\x81\x02\n\x05Field\x12\
    \x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x20\n\x0bdescription\x18\
    \x02\x20\x01(\tR\x0bdescription\x12@\n\x04type\x18\x03\x20\x01(\x0b2,.or\
    g.apache.beam.model.pipeline.v1.FieldTypeR\x04type\x12\x0e\n\x02id\x18\
    \x04\x20\x01(\x05R\x02id\x12+\n\x11encoding_position\x18\x05\x20\x01(\
    \x05R\x10encodingPosition\x12C\n\x07options\x18\x06\x20\x03(\x0b2).org.a\
    pache.beam.model.pipeline.v1.OptionR\x07options\"\x94\x04\n\tFieldType\
    \x12\x1a\n\x08nullable\x18\x01\x20\x01(\x08R\x08nullable\x12P\n\x0batomi\
    c_type\x18\x02\x20\x01(\x0e2-.org.apache.beam.model.pipeline.v1.AtomicTy\
    peH\0R\natomicType\x12M\n\narray_type\x18\x03\x20\x01(\x0b2,.org.apache.\
    beam.model.pipeline.v1.ArrayTypeH\0R\tarrayType\x12V\n\riterable_type\
    \x18\x04\x20\x01(\x0b2/.org.apache.beam.model.pipeline.v1.IterableTypeH\
    \0R\x0citerableType\x12G\n\x08map_type\x18\x05\x20\x01(\x0b2*.org.apache\
    .beam.model.pipeline.v1.MapTypeH\0R\x07mapType\x12G\n\x08row_type\x18\
    \x06\x20\x01(\x0b2*.org.apache.beam.model.pipeline.v1.RowTypeH\0R\x07row\
    Type\x12S\n\x0clogical_type\x18\x07\x20\x01(\x0b2..org.apache.beam.model\
    .pipeline.v1.LogicalTypeH\0R\x0blogicalTypeB\x0b\n\ttype_info\"\\\n\tArr\
    ayType\x12O\n\x0celement_type\x18\x01\x20\x01(\x0b2,.org.apache.beam.mod\
    el.pipeline.v1.FieldTypeR\x0belementType\"_\n\x0cIterableType\x12O\n\x0c\
    element_type\x18\x01\x20\x01(\x0b2,.org.apache.beam.model.pipeline.v1.Fi\
    eldTypeR\x0belementType\"\x9f\x01\n\x07MapType\x12G\n\x08key_type\x18\
    \x01\x20\x01(\x0b2,.org.apache.beam.model.pipeline.v1.FieldTypeR\x07keyT\
    ype\x12K\n\nvalue_type\x18\x02\x20\x01(\x0b2,.org.apache.beam.model.pipe\
    line.v1.FieldTypeR\tvalueType\"L\n\x07RowType\x12A\n\x06schema\x18\x01\
    \x20\x01(\x0b2).org.apache.beam.model.pipeline.v1.SchemaR\x06schema\"\
    \xad\x02\n\x0bLogicalType\x12\x10\n\x03urn\x18\x01\x20\x01(\tR\x03urn\
    \x12\x18\n\x07payload\x18\x02\x20\x01(\x0cR\x07payload\x12T\n\x0ereprese\
    ntation\x18\x03\x20\x01(\x0b2,.org.apache.beam.model.pipeline.v1.FieldTy\
    peR\x0erepresentation\x12Q\n\rargument_type\x18\x04\x20\x01(\x0b2,.org.a\
    pache.beam.model.pipeline.v1.FieldTypeR\x0cargumentType\x12I\n\x08argume\
    nt\x18\x05\x20\x01(\x0b2-.org.apache.beam.model.pipeline.v1.FieldValueR\
    \x08argument\"\x97\x01\n\x0cLogicalTypes\"\x86\x01\n\x04Enum\x12?\n\x0fP\
    YTHON_CALLABLE\x10\0\x1a*\xa2\xb4\xfa\xc2\x05$beam:logical_type:python_c\
    allable:v1\x12=\n\x0eMICROS_INSTANT\x10\x01\x1a)\xa2\xb4\xfa\xc2\x05#bea\
    m:logical_type:micros_instant:v1\"\xa3\x01\n\x06Option\x12\x12\n\x04name\
    \x18\x01\x20\x01(\tR\x04name\x12@\n\x04type\x18\x02\x20\x01(\x0b2,.org.a\
    pache.beam.model.pipeline.v1.FieldTypeR\x04type\x12C\n\x05value\x18\x03\
    \x20\x01(\x0b2-.org.apache.beam.model.pipeline.v1.FieldValueR\x05value\"\
    L\n\x03Row\x12E\n\x06values\x18\x01\x20\x03(\x0b2-.org.apache.beam.model\
    .pipeline.v1.FieldValueR\x06values\"\xa5\x04\n\nFieldValue\x12W\n\x0cato\
    mic_value\x18\x01\x20\x01(\x0b22.org.apache.beam.model.pipeline.v1.Atomi\
    cTypeValueH\0R\x0batomicValue\x12T\n\x0barray_value\x18\x02\x20\x01(\x0b\
    21.org.apache.beam.model.pipeline.v1.ArrayTypeValueH\0R\narrayValue\x12]\
    \n\x0eiterable_value\x18\x03\x20\x01(\x0b24.org.apache.beam.model.pipeli\
    ne.v1.IterableTypeValueH\0R\riterableValue\x12N\n\tmap_value\x18\x04\x20\
    \x01(\x0b2/.org.apache.beam.model.pipeline.v1.MapTypeValueH\0R\x08mapVal\
    ue\x12E\n\trow_value\x18\x05\x20\x01(\x0b2&.org.apache.beam.model.pipeli\
    ne.v1.RowH\0R\x08rowValue\x12c\n\x12logical_type_value\x18\x06\x20\x01(\
    \x0b23.org.apache.beam.model.pipeline.v1.LogicalTypeValueH\0R\x10logical\
    TypeValueB\r\n\x0bfield_value\"\xf8\x01\n\x0fAtomicTypeValue\x12\x14\n\
    \x04byte\x18\x01\x20\x01(\x05H\0R\x04byte\x12\x16\n\x05int16\x18\x02\x20\
    \x01(\x05H\0R\x05int16\x12\x16\n\x05int32\x18\x03\x20\x01(\x05H\0R\x05in\
    t32\x12\x16\n\x05int64\x18\x04\x20\x01(\x03H\0R\x05int64\x12\x16\n\x05fl\
    oat\x18\x05\x20\x01(\x02H\0R\x05float\x12\x18\n\x06double\x18\x06\x20\
    \x01(\x01H\0R\x06double\x12\x18\n\x06string\x18\x07\x20\x01(\tH\0R\x06st\
    ring\x12\x1a\n\x07boolean\x18\x08\x20\x01(\x08H\0R\x07boolean\x12\x16\n\
    \x05bytes\x18\t\x20\x01(\x0cH\0R\x05bytesB\x07\n\x05value\"Y\n\x0eArrayT\
    ypeValue\x12G\n\x07element\x18\x01\x20\x03(\x0b2-.org.apache.beam.model.\
    pipeline.v1.FieldValueR\x07element\"\\\n\x11IterableTypeValue\x12G\n\x07\
    element\x18\x01\x20\x03(\x0b2-.org.apache.beam.model.pipeline.v1.FieldVa\
    lueR\x07element\"Y\n\x0cMapTypeValue\x12I\n\x07entries\x18\x01\x20\x03(\
    \x0b2/.org.apache.beam.model.pipeline.v1.MapTypeEntryR\x07entries\"\x94\
    \x01\n\x0cMapTypeEntry\x12?\n\x03key\x18\x01\x20\x01(\x0b2-.org.apache.b\
    eam.model.pipeline.v1.FieldValueR\x03key\x12C\n\x05value\x18\x02\x20\x01\
    (\x0b2-.org.apache.beam.model.pipeline.v1.FieldValueR\x05value\"W\n\x10L\
    ogicalTypeValue\x12C\n\x05value\x18\x01\x20\x01(\x0b2-.org.apache.beam.m\
    odel.pipeline.v1.FieldValueR\x05value*\x83\x01\n\nAtomicType\x12\x0f\n\
    \x0bUNSPECIFIED\x10\0\x12\x08\n\x04BYTE\x10\x01\x12\t\n\x05INT16\x10\x02\
    \x12\t\n\x05INT32\x10\x03\x12\t\n\x05INT64\x10\x04\x12\t\n\x05FLOAT\x10\
    \x05\x12\n\n\x06DOUBLE\x10\x06\x12\n\n\x06STRING\x10\x07\x12\x0b\n\x07BO\
    OLEAN\x10\x08\x12\t\n\x05BYTES\x10\tBx\n!org.apache.beam.model.pipeline.\
    v1B\tSchemaApiZHgithub.com/apache/beam/sdks/v2/go/pkg/beam/model/pipelin\
    e_v1;pipeline_v1b\x06proto3\
";

/// `FileDescriptorProto` object which was a source for this generated file
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
    file_descriptor_proto_lazy.get(|| {
        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
    })
}

/// `FileDescriptor` object which allows dynamic access to files
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
    file_descriptor.get(|| {
        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
            let mut deps = ::std::vec::Vec::with_capacity(1);
            deps.push(super::beam_runner_api::file_descriptor().clone());
            let mut messages = ::std::vec::Vec::with_capacity(18);
            messages.push(Schema::generated_message_descriptor_data());
            messages.push(Field::generated_message_descriptor_data());
            messages.push(FieldType::generated_message_descriptor_data());
            messages.push(ArrayType::generated_message_descriptor_data());
            messages.push(IterableType::generated_message_descriptor_data());
            messages.push(MapType::generated_message_descriptor_data());
            messages.push(RowType::generated_message_descriptor_data());
            messages.push(LogicalType::generated_message_descriptor_data());
            messages.push(LogicalTypes::generated_message_descriptor_data());
            messages.push(Option::generated_message_descriptor_data());
            messages.push(Row::generated_message_descriptor_data());
            messages.push(FieldValue::generated_message_descriptor_data());
            messages.push(AtomicTypeValue::generated_message_descriptor_data());
            messages.push(ArrayTypeValue::generated_message_descriptor_data());
            messages.push(IterableTypeValue::generated_message_descriptor_data());
            messages.push(MapTypeValue::generated_message_descriptor_data());
            messages.push(MapTypeEntry::generated_message_descriptor_data());
            messages.push(LogicalTypeValue::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(2);
            enums.push(AtomicType::generated_enum_descriptor_data());
            enums.push(logical_types::Enum::generated_enum_descriptor_data());
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}